diff --git a/apps/sim/app/api/billing/update-cost/route.ts b/apps/sim/app/api/billing/update-cost/route.ts
index 65899d55572..743ddb17011 100644
--- a/apps/sim/app/api/billing/update-cost/route.ts
+++ b/apps/sim/app/api/billing/update-cost/route.ts
@@ -4,7 +4,7 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { recordUsage } from '@/lib/billing/core/usage-log'
 import { checkAndBillOverageThreshold } from '@/lib/billing/threshold-billing'
-import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
 import { isBillingEnabled } from '@/lib/core/config/feature-flags'
 import { generateRequestId } from '@/lib/core/utils/request'
 
diff --git a/apps/sim/app/api/copilot/api-keys/validate/route.ts b/apps/sim/app/api/copilot/api-keys/validate/route.ts
index 77521f3b3ed..1c1df540132 100644
--- a/apps/sim/app/api/copilot/api-keys/validate/route.ts
+++ b/apps/sim/app/api/copilot/api-keys/validate/route.ts
@@ -1,8 +1,11 @@
+import { db } from '@sim/db'
+import { user } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { checkServerSideUsageLimits } from '@/lib/billing/calculations/usage-monitor'
-import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
 
 const logger = createLogger('CopilotApiKeysValidate')
 
@@ -34,6 +37,12 @@ export async function POST(req: NextRequest) {
 
     const { userId } = validationResult.data
 
+    const [existingUser] = await db.select().from(user).where(eq(user.id, userId)).limit(1)
+    if (!existingUser) {
+      logger.warn('[API VALIDATION] userId does not exist', { userId })
+      return NextResponse.json({ error: 'User not found' }, { status: 403 })
+    }
+
     logger.info('[API VALIDATION] Validating usage limit', { userId })
 
     const { isExceeded, currentUsage, limit } = await checkServerSideUsageLimits(userId)
diff --git a/apps/sim/app/api/copilot/chat/abort/route.ts b/apps/sim/app/api/copilot/chat/abort/route.ts
index 33fe68c8d88..5cd333f0731 100644
--- a/apps/sim/app/api/copilot/chat/abort/route.ts
+++ b/apps/sim/app/api/copilot/chat/abort/route.ts
@@ -1,10 +1,12 @@
+import { createLogger } from '@sim/logger'
 import { NextResponse } from 'next/server'
 import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
-import { abortActiveStream, waitForPendingChatStream } from '@/lib/copilot/chat-streaming'
 import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+import { abortActiveStream } from '@/lib/copilot/request/session/abort'
 import { env } from '@/lib/core/config/env'
 
+const logger = createLogger('CopilotChatAbortAPI')
 const GO_EXPLICIT_ABORT_TIMEOUT_MS = 3000
 
 export async function POST(request: Request) {
@@ -15,7 +17,12 @@ export async function POST(request: Request) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
   }
 
-  const body = await request.json().catch(() => ({}))
+  const body = await request.json().catch((err) => {
+    logger.warn('Abort request body parse failed; continuing with empty object', {
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return {}
+  })
   const streamId = typeof body.streamId === 'string' ? body.streamId : ''
   let chatId = typeof body.chatId === 'string' ? body.chatId : ''
 
@@ -24,7 +31,13 @@ export async function POST(request: Request) {
   }
 
   if (!chatId) {
-    const run = await getLatestRunForStream(streamId, authenticatedUserId).catch(() => null)
+    const run = await getLatestRunForStream(streamId, authenticatedUserId).catch((err) => {
+      logger.warn('getLatestRunForStream failed while resolving chatId for abort', {
+        streamId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return null
+    })
     if (run?.chatId) {
       chatId = run.chatId
     }
@@ -50,15 +63,13 @@ export async function POST(request: Request) {
     if (!response.ok) {
       throw new Error(`Explicit abort marker request failed: ${response.status}`)
     }
-  } catch {
-    // best effort: local abort should still proceed even if Go marker fails
+  } catch (err) {
+    logger.warn('Explicit abort marker request failed; proceeding with local abort', {
+      streamId,
+      error: err instanceof Error ? err.message : String(err),
+    })
   }
 
   const aborted = await abortActiveStream(streamId)
-  if (chatId) {
-    await waitForPendingChatStream(chatId, GO_EXPLICIT_ABORT_TIMEOUT_MS + 1000, streamId).catch(
-      () => false
-    )
-  }
   return NextResponse.json({ aborted })
 }
diff --git a/apps/sim/app/api/copilot/chat/delete/route.test.ts b/apps/sim/app/api/copilot/chat/delete/route.test.ts
index c53c2a11256..0493b3ffe89 100644
--- a/apps/sim/app/api/copilot/chat/delete/route.test.ts
+++ b/apps/sim/app/api/copilot/chat/delete/route.test.ts
@@ -36,11 +36,11 @@ vi.mock('drizzle-orm', () => ({
   eq: vi.fn((field: unknown, value: unknown) => ({ field, value, type: 'eq' })),
 }))
 
-vi.mock('@/lib/copilot/chat-lifecycle', () => ({
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
   getAccessibleCopilotChat: mockGetAccessibleCopilotChat,
 }))
 
-vi.mock('@/lib/copilot/task-events', () => ({
+vi.mock('@/lib/copilot/tasks', () => ({
   taskPubSub: { publishStatusChanged: vi.fn() },
 }))
 
diff --git a/apps/sim/app/api/copilot/chat/delete/route.ts b/apps/sim/app/api/copilot/chat/delete/route.ts
index 652f732e676..1742d9e7e55 100644
--- a/apps/sim/app/api/copilot/chat/delete/route.ts
+++ b/apps/sim/app/api/copilot/chat/delete/route.ts
@@ -5,8 +5,8 @@ import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getSession } from '@/lib/auth'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
-import { taskPubSub } from '@/lib/copilot/task-events'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import { taskPubSub } from '@/lib/copilot/tasks'
 
 const logger = createLogger('DeleteChatAPI')
 
diff --git a/apps/sim/app/api/copilot/chat/queries.ts b/apps/sim/app/api/copilot/chat/queries.ts
new file mode 100644
index 00000000000..6f1f548a09f
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/queries.ts
@@ -0,0 +1,119 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, desc, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createBadRequestResponse,
+  createInternalServerErrorResponse,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request/http'
+import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('CopilotChatAPI')
+
+function transformChat(chat: {
+  id: string
+  title: string | null
+  model: string | null
+  messages: unknown
+  planArtifact?: unknown
+  config?: unknown
+  conversationId?: string | null
+  resources?: unknown
+  createdAt: Date | null
+  updatedAt: Date | null
+}) {
+  return {
+    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,
+    ...('conversationId' in chat ? { activeStreamId: chat.conversationId || null } : {}),
+    ...('resources' in chat
+      ? { resources: Array.isArray(chat.resources) ? chat.resources : [] }
+      : {}),
+    createdAt: chat.createdAt,
+    updatedAt: chat.updatedAt,
+  }
+}
+
+export async function GET(req: NextRequest) {
+  try {
+    const { searchParams } = new URL(req.url)
+    const workflowId = searchParams.get('workflowId')
+    const workspaceId = searchParams.get('workspaceId')
+    const chatId = searchParams.get('chatId')
+
+    const { userId: authenticatedUserId, isAuthenticated } =
+      await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !authenticatedUserId) {
+      return createUnauthorizedResponse()
+    }
+
+    if (chatId) {
+      const chat = await getAccessibleCopilotChat(chatId, authenticatedUserId)
+      if (!chat) {
+        return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
+      }
+
+      logger.info(`Retrieved chat ${chatId}`)
+      return NextResponse.json({ success: true, chat: transformChat(chat) })
+    }
+
+    if (!workflowId && !workspaceId) {
+      return createBadRequestResponse('workflowId, workspaceId, or chatId is required')
+    }
+
+    if (workspaceId) {
+      await assertActiveWorkspaceAccess(workspaceId, authenticatedUserId)
+    }
+
+    if (workflowId) {
+      const authorization = await authorizeWorkflowByWorkspacePermission({
+        workflowId,
+        userId: authenticatedUserId,
+        action: 'read',
+      })
+      if (!authorization.allowed) {
+        return createUnauthorizedResponse()
+      }
+    }
+
+    const scopeFilter = workflowId
+      ? eq(copilotChats.workflowId, workflowId)
+      : eq(copilotChats.workspaceId, workspaceId!)
+
+    const chats = 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.userId, authenticatedUserId), scopeFilter))
+      .orderBy(desc(copilotChats.updatedAt))
+
+    const scope = workflowId ? `workflow ${workflowId}` : `workspace ${workspaceId}`
+    logger.info(`Retrieved ${chats.length} chats for ${scope}`)
+
+    return NextResponse.json({
+      success: true,
+      chats: chats.map(transformChat),
+    })
+  } catch (error) {
+    logger.error('Error fetching copilot chats:', error)
+    return createInternalServerErrorResponse('Failed to fetch chats')
+  }
+}
diff --git a/apps/sim/app/api/copilot/chat/rename/route.ts b/apps/sim/app/api/copilot/chat/rename/route.ts
new file mode 100644
index 00000000000..7587f577411
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/rename/route.ts
@@ -0,0 +1,65 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getSession } from '@/lib/auth'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import { taskPubSub } from '@/lib/copilot/tasks'
+
+const logger = createLogger('RenameChatAPI')
+
+const RenameChatSchema = z.object({
+  chatId: z.string().min(1),
+  title: z.string().min(1).max(200),
+})
+
+export async function PATCH(request: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const { chatId, title } = RenameChatSchema.parse(body)
+
+    const chat = await getAccessibleCopilotChat(chatId, session.user.id)
+    if (!chat) {
+      return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
+    }
+
+    const now = new Date()
+    const [updated] = await db
+      .update(copilotChats)
+      .set({ title, updatedAt: now, lastSeenAt: now })
+      .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, session.user.id)))
+      .returning({ id: copilotChats.id, workspaceId: copilotChats.workspaceId })
+
+    if (!updated) {
+      return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
+    }
+
+    logger.info('Chat renamed', { chatId, title })
+
+    if (updated.workspaceId) {
+      taskPubSub?.publishStatusChanged({
+        workspaceId: updated.workspaceId,
+        chatId,
+        type: 'renamed',
+      })
+    }
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+    logger.error('Error renaming chat:', error)
+    return NextResponse.json({ success: false, error: 'Failed to rename chat' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/copilot/chat/resources/route.ts b/apps/sim/app/api/copilot/chat/resources/route.ts
index 8d528150218..0d80be8e77b 100644
--- a/apps/sim/app/api/copilot/chat/resources/route.ts
+++ b/apps/sim/app/api/copilot/chat/resources/route.ts
@@ -10,8 +10,8 @@ import {
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import type { ChatResource, ResourceType } from '@/lib/copilot/resources'
+} from '@/lib/copilot/request/http'
+import type { ChatResource, ResourceType } from '@/lib/copilot/resources/persistence'
 
 const logger = createLogger('CopilotChatResourcesAPI')
 
diff --git a/apps/sim/app/api/copilot/chat/route.ts b/apps/sim/app/api/copilot/chat/route.ts
index 21f83737066..332665f8dc5 100644
--- a/apps/sim/app/api/copilot/chat/route.ts
+++ b/apps/sim/app/api/copilot/chat/route.ts
@@ -1,47 +1,45 @@
 import { db } from '@sim/db'
 import { copilotChats } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, desc, eq, sql } from 'drizzle-orm'
+import { eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getSession } from '@/lib/auth'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { getAccessibleCopilotChat, resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
-import { buildCopilotRequestPayload } from '@/lib/copilot/chat-payload'
+import { type ChatLoadResult, resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
+import { buildCopilotRequestPayload } from '@/lib/copilot/chat/payload'
 import {
-  acquirePendingChatStream,
-  createSSEStream,
-  releasePendingChatStream,
-  requestChatTitle,
-  SSE_RESPONSE_HEADERS,
-} from '@/lib/copilot/chat-streaming'
-import { COPILOT_REQUEST_MODES } from '@/lib/copilot/models'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { getStreamMeta, readStreamEvents } from '@/lib/copilot/orchestrator/stream/buffer'
-import type { OrchestratorResult } from '@/lib/copilot/orchestrator/types'
-import { resolveActiveResourceContext } from '@/lib/copilot/process-contents'
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import {
+  processContextsServer,
+  resolveActiveResourceContext,
+} from '@/lib/copilot/chat/process-contents'
+import { COPILOT_REQUEST_MODES } from '@/lib/copilot/constants'
 import {
-  authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
-  createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { generateId } from '@/lib/core/utils/uuid'
-import { captureServerEvent } from '@/lib/posthog/server'
+} from '@/lib/copilot/request/http'
+import { createSSEStream, SSE_RESPONSE_HEADERS } from '@/lib/copilot/request/lifecycle/start'
 import {
-  authorizeWorkflowByWorkspacePermission,
-  resolveWorkflowIdForUser,
-} from '@/lib/workflows/utils'
-import {
-  assertActiveWorkspaceAccess,
-  getUserEntityPermissions,
-} from '@/lib/workspaces/permissions/utils'
+  acquirePendingChatStream,
+  getPendingChatStreamId,
+  releasePendingChatStream,
+} from '@/lib/copilot/request/session'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import { getWorkflowById, resolveWorkflowIdForUser } from '@/lib/workflows/utils'
+import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
+import type { ChatContext } from '@/stores/panel'
 
 export const maxDuration = 3600
 
 const logger = createLogger('CopilotChatAPI')
 
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
 const FileAttachmentSchema = z.object({
   id: z.string(),
   key: z.string(),
@@ -68,7 +66,6 @@ const ChatMessageSchema = z.object({
   mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
   prefetch: z.boolean().optional(),
   createNewChat: z.boolean().optional().default(false),
-  stream: z.boolean().optional().default(true),
   implicitFeedback: z.string().optional(),
   fileAttachments: z.array(FileAttachmentSchema).optional(),
   resourceAttachments: z.array(ResourceAttachmentSchema).optional(),
@@ -108,27 +105,25 @@ const ChatMessageSchema = z.object({
   userTimezone: z.string().optional(),
 })
 
-/**
- * POST /api/copilot/chat
- * Send messages to sim agent and handle chat persistence
- */
+// ---------------------------------------------------------------------------
+// POST /api/copilot/chat
+// ---------------------------------------------------------------------------
+
 export async function POST(req: NextRequest) {
   const tracker = createRequestTracker()
   let actualChatId: string | undefined
-  let pendingChatStreamAcquired = false
-  let pendingChatStreamHandedOff = false
-  let pendingChatStreamID: string | undefined
+  let chatStreamLockAcquired = false
+  let userMessageIdToUse = ''
 
   try {
-    // Get session to access user information including name
+    // 1. Auth
     const session = await getSession()
-
     if (!session?.user?.id) {
       return createUnauthorizedResponse()
     }
-
     const authenticatedUserId = session.user.id
 
+    // 2. Parse & validate
     const body = await req.json()
     const {
       message,
@@ -141,7 +136,6 @@ export async function POST(req: NextRequest) {
       mode,
       prefetch,
       createNewChat,
-      stream,
       implicitFeedback,
       fileAttachments,
       resourceAttachments,
@@ -155,17 +149,12 @@ export async function POST(req: NextRequest) {
       ? contexts.map((ctx) => {
           if (ctx.kind !== 'blocks') return ctx
           if (Array.isArray(ctx.blockIds) && ctx.blockIds.length > 0) return ctx
-          if (ctx.blockId) {
-            return {
-              ...ctx,
-              blockIds: [ctx.blockId],
-            }
-          }
+          if (ctx.blockId) return { ...ctx, blockIds: [ctx.blockId] }
           return ctx
         })
       : contexts
 
-    // Copilot route always requires a workflow scope
+    // 3. Resolve workflow & workspace
     const resolved = await resolveWorkflowIdForUser(
       authenticatedUserId,
       providedWorkflowId,
@@ -177,63 +166,28 @@ export async function POST(req: NextRequest) {
         'No workflows found. Create a workflow first or provide a valid workflowId.'
       )
     }
-    const workflowId = resolved.workflowId
-    const workflowResolvedName = resolved.workflowName
+    const { workflowId, workflowName: workflowResolvedName } = resolved
 
-    // Resolve workspace from workflow so it can be sent as implicit context to the copilot.
     let resolvedWorkspaceId: string | undefined
     try {
-      const { getWorkflowById } = await import('@/lib/workflows/utils')
       const wf = await getWorkflowById(workflowId)
       resolvedWorkspaceId = wf?.workspaceId ?? undefined
     } catch {
-      logger
-        .withMetadata({ requestId: tracker.requestId, messageId: userMessageId })
-        .warn('Failed to resolve workspaceId from workflow')
+      logger.warn(`[${tracker.requestId}] Failed to resolve workspaceId from workflow`)
     }
 
-    captureServerEvent(
-      authenticatedUserId,
-      'copilot_chat_sent',
-      {
-        workflow_id: workflowId,
-        workspace_id: resolvedWorkspaceId ?? '',
-        has_file_attachments: Array.isArray(fileAttachments) && fileAttachments.length > 0,
-        has_contexts: Array.isArray(contexts) && contexts.length > 0,
-        mode,
-      },
-      {
-        groups: resolvedWorkspaceId ? { workspace: resolvedWorkspaceId } : undefined,
-        setOnce: { first_copilot_use_at: new Date().toISOString() },
-      }
-    )
+    userMessageIdToUse = userMessageId || crypto.randomUUID()
+    const selectedModel = model || 'claude-opus-4-6'
 
-    const userMessageIdToUse = userMessageId || generateId()
-    const reqLogger = logger.withMetadata({
-      requestId: tracker.requestId,
-      messageId: userMessageIdToUse,
+    logger.info(`[${tracker.requestId}] Received chat POST`, {
+      workflowId,
+      contextsCount: Array.isArray(normalizedContexts) ? normalizedContexts.length : 0,
     })
-    try {
-      reqLogger.info('Received chat POST', {
-        workflowId,
-        hasContexts: Array.isArray(normalizedContexts),
-        contextsCount: Array.isArray(normalizedContexts) ? normalizedContexts.length : 0,
-        contextsPreview: Array.isArray(normalizedContexts)
-          ? normalizedContexts.map((c: any) => ({
-              kind: c?.kind,
-              chatId: c?.chatId,
-              workflowId: c?.workflowId,
-              executionId: (c as any)?.executionId,
-              label: c?.label,
-            }))
-          : undefined,
-      })
-    } catch {}
 
-    let currentChat: any = null
-    let conversationHistory: any[] = []
+    // 4. Resolve or create chat
+    let currentChat: ChatLoadResult['chat'] = null
+    let conversationHistory: unknown[] = []
     actualChatId = chatId
-    const selectedModel = model || 'claude-opus-4-6'
 
     if (chatId || createNewChat) {
       const chatResult = await resolveOrCreateChat({
@@ -253,37 +207,48 @@ export async function POST(req: NextRequest) {
       }
     }
 
+    if (actualChatId) {
+      chatStreamLockAcquired = await acquirePendingChatStream(actualChatId, userMessageIdToUse)
+      if (!chatStreamLockAcquired) {
+        const activeStreamId = await getPendingChatStreamId(actualChatId)
+        return NextResponse.json(
+          {
+            error: 'A response is already in progress for this chat.',
+            ...(activeStreamId ? { activeStreamId } : {}),
+          },
+          { status: 409 }
+        )
+      }
+    }
+
+    // 5. Process contexts
     let agentContexts: Array<{ type: string; content: string }> = []
+
     if (Array.isArray(normalizedContexts) && normalizedContexts.length > 0) {
       try {
-        const { processContextsServer } = await import('@/lib/copilot/process-contents')
         const processed = await processContextsServer(
-          normalizedContexts as any,
+          normalizedContexts as ChatContext[],
           authenticatedUserId,
           message,
           resolvedWorkspaceId,
           actualChatId
         )
         agentContexts = processed
-        reqLogger.info('Contexts processed for request', {
+        logger.info(`[${tracker.requestId}] Contexts processed`, {
           processedCount: agentContexts.length,
           kinds: agentContexts.map((c) => c.type),
-          lengthPreview: agentContexts.map((c) => c.content?.length ?? 0),
         })
-        if (
-          Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 &&
-          agentContexts.length === 0
-        ) {
-          reqLogger.warn(
-            'Contexts provided but none processed. Check executionId for logs contexts.'
+        if (agentContexts.length === 0) {
+          logger.warn(
+            `[${tracker.requestId}] Contexts provided but none processed. Check executionId for logs contexts.`
           )
         }
       } catch (e) {
-        reqLogger.error('Failed to process contexts', e)
+        logger.error(`[${tracker.requestId}] Failed to process contexts`, e)
       }
     }
 
+    // 5b. Process resource attachments
     if (
       Array.isArray(resourceAttachments) &&
       resourceAttachments.length > 0 &&
@@ -299,26 +264,30 @@ export async function POST(req: NextRequest) {
             actualChatId
           )
           if (!ctx) return null
-          return {
-            ...ctx,
-            tag: r.active ? '@active_tab' : '@open_tab',
-          }
+          return { ...ctx, tag: r.active ? '@active_tab' : '@open_tab' }
         })
       )
       for (const result of results) {
         if (result.status === 'fulfilled' && result.value) {
           agentContexts.push(result.value)
         } else if (result.status === 'rejected') {
-          reqLogger.error('Failed to resolve resource attachment', result.reason)
+          logger.error(
+            `[${tracker.requestId}] Failed to resolve resource attachment`,
+            result.reason
+          )
         }
       }
     }
 
-    const effectiveMode = mode === 'agent' ? 'build' : mode
-
+    // 6. Build copilot request payload
     const userPermission = resolvedWorkspaceId
       ? await getUserEntityPermissions(authenticatedUserId, 'workspace', resolvedWorkspaceId).catch(
-          () => null
+          (err) => {
+            logger.warn('Failed to load user permissions', {
+              error: err instanceof Error ? err.message : String(err),
+            })
+            return null
+          }
         )
       : null
 
@@ -342,55 +311,24 @@ export async function POST(req: NextRequest) {
         userPermission: userPermission ?? undefined,
         userTimezone,
       },
-      {
-        selectedModel,
-      }
+      { selectedModel }
     )
 
-    try {
-      reqLogger.info('About to call Sim Agent', {
-        hasContext: agentContexts.length > 0,
-        contextCount: agentContexts.length,
-        hasFileAttachments: Array.isArray(requestPayload.fileAttachments),
-        messageLength: message.length,
-        mode: effectiveMode,
-        hasTools: Array.isArray(requestPayload.tools),
-        toolCount: Array.isArray(requestPayload.tools) ? requestPayload.tools.length : 0,
-        hasBaseTools: Array.isArray(requestPayload.baseTools),
-        baseToolCount: Array.isArray(requestPayload.baseTools)
-          ? requestPayload.baseTools.length
-          : 0,
-        hasCredentials: !!requestPayload.credentials,
-      })
-    } catch {}
-
-    if (stream && actualChatId) {
-      const acquired = await acquirePendingChatStream(actualChatId, userMessageIdToUse)
-      if (!acquired) {
-        return NextResponse.json(
-          {
-            error:
-              'A response is already in progress for this chat. Wait for it to finish or use Stop.',
-          },
-          { status: 409 }
-        )
-      }
-      pendingChatStreamAcquired = true
-      pendingChatStreamID = userMessageIdToUse
-    }
+    logger.info(`[${tracker.requestId}] About to call Sim Agent`, {
+      contextCount: agentContexts.length,
+      hasFileAttachments: Array.isArray(requestPayload.fileAttachments),
+      messageLength: message.length,
+      mode,
+    })
 
+    // 7. Persist user message
     if (actualChatId) {
-      const userMsg = {
+      const userMsg = buildPersistedUserMessage({
         id: userMessageIdToUse,
-        role: 'user' as const,
         content: message,
-        timestamp: new Date().toISOString(),
-        ...(fileAttachments && fileAttachments.length > 0 && { fileAttachments }),
-        ...(Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 && {
-            contexts: normalizedContexts,
-          }),
-      }
+        fileAttachments,
+        contexts: normalizedContexts,
+      })
 
       const [updated] = await db
         .update(copilotChats)
@@ -403,268 +341,66 @@ export async function POST(req: NextRequest) {
         .returning({ messages: copilotChats.messages })
 
       if (updated) {
-        const freshMessages: any[] = Array.isArray(updated.messages) ? updated.messages : []
-        conversationHistory = freshMessages.filter((m: any) => m.id !== userMessageIdToUse)
+        const freshMessages: Record<string, unknown>[] = Array.isArray(updated.messages)
+          ? updated.messages
+          : []
+        conversationHistory = freshMessages.filter(
+          (m: Record<string, unknown>) => m.id !== userMessageIdToUse
+        )
       }
     }
 
-    if (stream) {
-      const executionId = generateId()
-      const runId = generateId()
-      const sseStream = createSSEStream({
-        requestPayload,
-        userId: authenticatedUserId,
-        streamId: userMessageIdToUse,
-        executionId,
-        runId,
-        chatId: actualChatId,
-        currentChat,
-        isNewChat: conversationHistory.length === 0,
-        message,
-        titleModel: selectedModel,
-        titleProvider: provider,
-        requestId: tracker.requestId,
-        workspaceId: resolvedWorkspaceId,
-        pendingChatStreamAlreadyRegistered: Boolean(actualChatId && stream),
-        orchestrateOptions: {
-          userId: authenticatedUserId,
-          workflowId,
-          chatId: actualChatId,
-          executionId,
-          runId,
-          goRoute: '/api/copilot',
-          autoExecuteTools: true,
-          interactive: true,
-          onComplete: async (result: OrchestratorResult) => {
-            if (!actualChatId) return
-            if (!result.success) return
-
-            const assistantMessage: Record<string, unknown> = {
-              id: generateId(),
-              role: 'assistant' as const,
-              content: result.content,
-              timestamp: new Date().toISOString(),
-              ...(result.requestId ? { requestId: result.requestId } : {}),
-            }
-            if (result.toolCalls.length > 0) {
-              assistantMessage.toolCalls = result.toolCalls
-            }
-            if (result.contentBlocks.length > 0) {
-              assistantMessage.contentBlocks = result.contentBlocks.map((block) => {
-                const stored: Record<string, unknown> = { type: block.type }
-                if (block.content) stored.content = block.content
-                if (block.type === 'tool_call' && block.toolCall) {
-                  const state =
-                    block.toolCall.result?.success !== undefined
-                      ? block.toolCall.result.success
-                        ? 'success'
-                        : 'error'
-                      : block.toolCall.status
-                  const isSubagentTool = !!block.calledBy
-                  const isNonTerminal =
-                    state === 'cancelled' || state === 'pending' || state === 'executing'
-                  stored.toolCall = {
-                    id: block.toolCall.id,
-                    name: block.toolCall.name,
-                    state,
-                    ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
-                    ...(isSubagentTool && isNonTerminal
-                      ? {}
-                      : block.toolCall.params
-                        ? { params: block.toolCall.params }
-                        : {}),
-                    ...(block.calledBy ? { calledBy: block.calledBy } : {}),
-                  }
-                }
-                return stored
-              })
-            }
-
-            try {
-              const [row] = await db
-                .select({ messages: copilotChats.messages })
-                .from(copilotChats)
-                .where(eq(copilotChats.id, actualChatId))
-                .limit(1)
-
-              const msgs: any[] = Array.isArray(row?.messages) ? row.messages : []
-              const userIdx = msgs.findIndex((m: any) => m.id === userMessageIdToUse)
-              const alreadyHasResponse =
-                userIdx >= 0 &&
-                userIdx + 1 < msgs.length &&
-                (msgs[userIdx + 1] as any)?.role === 'assistant'
-
-              if (!alreadyHasResponse) {
-                await db
-                  .update(copilotChats)
-                  .set({
-                    messages: sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`,
-                    conversationId: sql`CASE WHEN ${copilotChats.conversationId} = ${userMessageIdToUse} THEN NULL ELSE ${copilotChats.conversationId} END`,
-                    updatedAt: new Date(),
-                  })
-                  .where(eq(copilotChats.id, actualChatId))
-              }
-            } catch (error) {
-              reqLogger.error('Failed to persist chat messages', {
-                chatId: actualChatId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-              })
-            }
-          },
-        },
-      })
-      pendingChatStreamHandedOff = true
-
-      return new Response(sseStream, { headers: SSE_RESPONSE_HEADERS })
-    }
-
-    const nsExecutionId = generateId()
-    const nsRunId = generateId()
+    // 8. Create SSE stream with onComplete for assistant message persistence
+    const executionId = crypto.randomUUID()
+    const runId = crypto.randomUUID()
 
-    if (actualChatId) {
-      await createRunSegment({
-        id: nsRunId,
-        executionId: nsExecutionId,
-        chatId: actualChatId,
-        userId: authenticatedUserId,
-        workflowId,
-        streamId: userMessageIdToUse,
-      }).catch(() => {})
-    }
-
-    const nonStreamingResult = await orchestrateCopilotStream(requestPayload, {
+    const sseStream = createSSEStream({
+      requestPayload,
       userId: authenticatedUserId,
-      workflowId,
+      streamId: userMessageIdToUse,
+      executionId,
+      runId,
       chatId: actualChatId,
-      executionId: nsExecutionId,
-      runId: nsRunId,
-      goRoute: '/api/copilot',
-      autoExecuteTools: true,
-      interactive: true,
-    })
-
-    const responseData = {
-      content: nonStreamingResult.content,
-      toolCalls: nonStreamingResult.toolCalls,
-      model: selectedModel,
-      provider: typeof requestPayload?.provider === 'string' ? requestPayload.provider : undefined,
-    }
-
-    reqLogger.info('Non-streaming response from orchestrator', {
-      hasContent: !!responseData.content,
-      contentLength: responseData.content?.length || 0,
-      model: responseData.model,
-      provider: responseData.provider,
-      toolCallsCount: responseData.toolCalls?.length || 0,
-    })
-
-    // Save messages if we have a chat
-    if (currentChat && responseData.content) {
-      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(normalizedContexts) &&
-          normalizedContexts.length > 0 && {
-            contexts: normalizedContexts,
-          }),
-        ...(Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 && {
-            contentBlocks: [
-              { type: 'contexts', contexts: normalizedContexts as any, timestamp: Date.now() },
-            ],
-          }),
-      }
-
-      const assistantMessage = {
-        id: generateId(),
-        role: 'assistant',
-        content: responseData.content,
-        timestamp: new Date().toISOString(),
-      }
-
-      const updatedMessages = [...conversationHistory, userMessage, assistantMessage]
-
-      // Start title generation in parallel if this is first message (non-streaming)
-      if (actualChatId && !currentChat.title && conversationHistory.length === 0) {
-        reqLogger.info('Starting title generation for non-streaming response')
-        requestChatTitle({ message, model: selectedModel, provider, messageId: userMessageIdToUse })
-          .then(async (title) => {
-            if (title) {
-              await db
-                .update(copilotChats)
-                .set({
-                  title,
-                  updatedAt: new Date(),
-                })
-                .where(eq(copilotChats.id, actualChatId!))
-              reqLogger.info(`Generated and saved title: ${title}`)
-            }
-          })
-          .catch((error) => {
-            reqLogger.error('Title generation failed', error)
-          })
-      }
-
-      // Update chat in database immediately (without blocking for title)
-      await db
-        .update(copilotChats)
-        .set({
-          messages: updatedMessages,
-          updatedAt: new Date(),
-        })
-        .where(eq(copilotChats.id, actualChatId!))
-    }
-
-    reqLogger.info('Returning non-streaming response', {
-      duration: tracker.getDuration(),
-      chatId: actualChatId,
-      responseLength: responseData.content?.length || 0,
-    })
-
-    return NextResponse.json({
-      success: true,
-      response: responseData,
-      chatId: actualChatId,
-      metadata: {
-        requestId: tracker.requestId,
-        message,
-        duration: tracker.getDuration(),
+      currentChat,
+      isNewChat: conversationHistory.length === 0,
+      message,
+      titleModel: selectedModel,
+      titleProvider: provider,
+      requestId: tracker.requestId,
+      workspaceId: resolvedWorkspaceId,
+      orchestrateOptions: {
+        userId: authenticatedUserId,
+        workflowId,
+        chatId: actualChatId,
+        executionId,
+        runId,
+        goRoute: '/api/copilot',
+        autoExecuteTools: true,
+        interactive: true,
+        onComplete: buildOnComplete(actualChatId, userMessageIdToUse, tracker.requestId),
       },
     })
+
+    return new Response(sseStream, { headers: SSE_RESPONSE_HEADERS })
   } catch (error) {
-    if (
-      actualChatId &&
-      pendingChatStreamAcquired &&
-      !pendingChatStreamHandedOff &&
-      pendingChatStreamID
-    ) {
-      await releasePendingChatStream(actualChatId, pendingChatStreamID).catch(() => {})
+    if (chatStreamLockAcquired && actualChatId && userMessageIdToUse) {
+      await releasePendingChatStream(actualChatId, userMessageIdToUse)
     }
     const duration = tracker.getDuration()
 
     if (error instanceof z.ZodError) {
-      logger
-        .withMetadata({ requestId: tracker.requestId, messageId: pendingChatStreamID ?? undefined })
-        .error('Validation error', {
-          duration,
-          errors: error.errors,
-        })
+      logger.error(`[${tracker.requestId}] Validation error:`, { duration, errors: error.errors })
       return NextResponse.json(
         { error: 'Invalid request data', details: error.errors },
         { status: 400 }
       )
     }
 
-    logger
-      .withMetadata({ requestId: tracker.requestId, messageId: pendingChatStreamID ?? undefined })
-      .error('Error handling copilot chat', {
-        duration,
-        error: error instanceof Error ? error.message : 'Unknown error',
-        stack: error instanceof Error ? error.stack : undefined,
-      })
+    logger.error(`[${tracker.requestId}] Error handling copilot chat:`, {
+      duration,
+      error: error instanceof Error ? error.message : 'Unknown error',
+      stack: error instanceof Error ? error.stack : undefined,
+    })
 
     return NextResponse.json(
       { error: error instanceof Error ? error.message : 'Internal server error' },
@@ -673,132 +409,55 @@ export async function POST(req: NextRequest) {
   }
 }
 
-export async function GET(req: NextRequest) {
-  try {
-    const { searchParams } = new URL(req.url)
-    const workflowId = searchParams.get('workflowId')
-    const workspaceId = searchParams.get('workspaceId')
-    const chatId = searchParams.get('chatId')
-
-    const { userId: authenticatedUserId, isAuthenticated } =
-      await authenticateCopilotRequestSessionOnly()
-    if (!isAuthenticated || !authenticatedUserId) {
-      return createUnauthorizedResponse()
-    }
-
-    if (chatId) {
-      const chat = await getAccessibleCopilotChat(chatId, authenticatedUserId)
+// ---------------------------------------------------------------------------
+// onComplete: persist assistant message after streaming finishes
+// ---------------------------------------------------------------------------
 
-      if (!chat) {
-        return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
-      }
+function buildOnComplete(
+  chatId: string | undefined,
+  userMessageId: string,
+  requestId: string
+): (result: OrchestratorResult) => Promise<void> {
+  return async (result) => {
+    if (!chatId || !result.success) return
 
-      let streamSnapshot: {
-        events: Array<{ eventId: number; streamId: string; event: Record<string, unknown> }>
-        status: string
-      } | null = null
-
-      if (chat.conversationId) {
-        try {
-          const [meta, events] = await Promise.all([
-            getStreamMeta(chat.conversationId),
-            readStreamEvents(chat.conversationId, 0),
-          ])
-          streamSnapshot = {
-            events: events || [],
-            status: meta?.status || 'unknown',
-          }
-        } catch (err) {
-          logger
-            .withMetadata({ messageId: chat.conversationId || undefined })
-            .warn('Failed to read stream snapshot for chat', {
-              chatId,
-              conversationId: chat.conversationId,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        }
-      }
+    const assistantMessage = buildPersistedAssistantMessage(result, result.requestId)
 
-      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,
-        conversationId: chat.conversationId || null,
-        resources: Array.isArray(chat.resources) ? chat.resources : [],
-        createdAt: chat.createdAt,
-        updatedAt: chat.updatedAt,
-        ...(streamSnapshot ? { streamSnapshot } : {}),
+    try {
+      const [row] = await db
+        .select({ messages: copilotChats.messages })
+        .from(copilotChats)
+        .where(eq(copilotChats.id, chatId))
+        .limit(1)
+
+      const msgs: Record<string, unknown>[] = Array.isArray(row?.messages) ? row.messages : []
+      const userIdx = msgs.findIndex((m: Record<string, unknown>) => m.id === userMessageId)
+      const alreadyHasResponse =
+        userIdx >= 0 &&
+        userIdx + 1 < msgs.length &&
+        (msgs[userIdx + 1] as Record<string, unknown>)?.role === 'assistant'
+
+      if (!alreadyHasResponse) {
+        await db
+          .update(copilotChats)
+          .set({
+            messages: sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`,
+            conversationId: sql`CASE WHEN ${copilotChats.conversationId} = ${userMessageId} THEN NULL ELSE ${copilotChats.conversationId} END`,
+            updatedAt: new Date(),
+          })
+          .where(eq(copilotChats.id, chatId))
       }
-
-      logger
-        .withMetadata({ messageId: chat.conversationId || undefined })
-        .info(`Retrieved chat ${chatId}`)
-      return NextResponse.json({ success: true, chat: transformedChat })
-    }
-
-    if (!workflowId && !workspaceId) {
-      return createBadRequestResponse('workflowId, workspaceId, or chatId is required')
-    }
-
-    if (workspaceId) {
-      await assertActiveWorkspaceAccess(workspaceId, authenticatedUserId)
-    }
-
-    if (workflowId) {
-      const authorization = await authorizeWorkflowByWorkspacePermission({
-        workflowId,
-        userId: authenticatedUserId,
-        action: 'read',
+    } catch (error) {
+      logger.error(`[${requestId}] Failed to persist chat messages`, {
+        chatId,
+        error: error instanceof Error ? error.message : 'Unknown error',
       })
-      if (!authorization.allowed) {
-        return createUnauthorizedResponse()
-      }
     }
-
-    const scopeFilter = workflowId
-      ? eq(copilotChats.workflowId, workflowId)
-      : eq(copilotChats.workspaceId, workspaceId!)
-
-    const chats = 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.userId, authenticatedUserId), scopeFilter))
-      .orderBy(desc(copilotChats.updatedAt))
-
-    const transformedChats = chats.map((chat) => ({
-      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,
-    }))
-
-    const scope = workflowId ? `workflow ${workflowId}` : `workspace ${workspaceId}`
-    logger.info(`Retrieved ${transformedChats.length} chats for ${scope}`)
-
-    return NextResponse.json({
-      success: true,
-      chats: transformedChats,
-    })
-  } catch (error) {
-    logger.error('Error fetching copilot chats', error)
-    return createInternalServerErrorResponse('Failed to fetch chats')
   }
 }
+
+// ---------------------------------------------------------------------------
+// GET handler (read-only queries, extracted to queries.ts)
+// ---------------------------------------------------------------------------
+
+export { GET } from './queries'
diff --git a/apps/sim/app/api/copilot/chat/stream/route.test.ts b/apps/sim/app/api/copilot/chat/stream/route.test.ts
index 993f10501a8..ff5115e637a 100644
--- a/apps/sim/app/api/copilot/chat/stream/route.test.ts
+++ b/apps/sim/app/api/copilot/chat/stream/route.test.ts
@@ -4,25 +4,67 @@
 
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
 
-const { getStreamMeta, readStreamEvents, authenticateCopilotRequestSessionOnly } = vi.hoisted(
-  () => ({
-    getStreamMeta: vi.fn(),
-    readStreamEvents: vi.fn(),
-    authenticateCopilotRequestSessionOnly: vi.fn(),
-  })
-)
+const {
+  getLatestRunForStream,
+  readEvents,
+  checkForReplayGap,
+  authenticateCopilotRequestSessionOnly,
+} = vi.hoisted(() => ({
+  getLatestRunForStream: vi.fn(),
+  readEvents: vi.fn(),
+  checkForReplayGap: vi.fn(),
+  authenticateCopilotRequestSessionOnly: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  getLatestRunForStream,
+}))
 
-vi.mock('@/lib/copilot/orchestrator/stream/buffer', () => ({
-  getStreamMeta,
-  readStreamEvents,
+vi.mock('@/lib/copilot/request/session', () => ({
+  readEvents,
+  checkForReplayGap,
+  createEvent: (event: Record<string, unknown>) => ({
+    stream: {
+      streamId: event.streamId,
+      cursor: event.cursor,
+    },
+    seq: event.seq,
+    trace: { requestId: event.requestId ?? '' },
+    type: event.type,
+    payload: event.payload,
+  }),
+  encodeSSEEnvelope: (event: Record<string, unknown>) =>
+    new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`),
+  SSE_RESPONSE_HEADERS: {
+    'Content-Type': 'text/event-stream',
+  },
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly,
 }))
 
-import { GET } from '@/app/api/copilot/chat/stream/route'
+import { GET } from './route'
+
+async function readAllChunks(response: Response): Promise<string[]> {
+  const reader = response.body?.getReader()
+  expect(reader).toBeTruthy()
+
+  const chunks: string[] = []
+  while (true) {
+    const { done, value } = await reader!.read()
+    if (done) {
+      break
+    }
+    chunks.push(new TextDecoder().decode(value))
+  }
+  return chunks
+}
 
 describe('copilot chat stream replay route', () => {
   beforeEach(() => {
@@ -31,29 +73,54 @@ describe('copilot chat stream replay route', () => {
       userId: 'user-1',
       isAuthenticated: true,
     })
-    readStreamEvents.mockResolvedValue([])
+    readEvents.mockResolvedValue([])
+    checkForReplayGap.mockResolvedValue(null)
   })
 
-  it('stops replay polling when stream meta becomes cancelled', async () => {
-    getStreamMeta
+  it('stops replay polling when run becomes cancelled', async () => {
+    getLatestRunForStream
       .mockResolvedValueOnce({
         status: 'active',
-        userId: 'user-1',
+        executionId: 'exec-1',
+        id: 'run-1',
       })
       .mockResolvedValueOnce({
         status: 'cancelled',
-        userId: 'user-1',
+        executionId: 'exec-1',
+        id: 'run-1',
       })
 
     const response = await GET(
-      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1')
+      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0')
     )
 
-    const reader = response.body?.getReader()
-    expect(reader).toBeTruthy()
+    const chunks = await readAllChunks(response)
+    expect(chunks.join('')).toContain(
+      JSON.stringify({
+        status: MothershipStreamV1CompletionStatus.cancelled,
+        reason: 'terminal_status',
+      })
+    )
+    expect(getLatestRunForStream).toHaveBeenCalledTimes(2)
+  })
+
+  it('emits structured terminal replay error when run metadata disappears', async () => {
+    getLatestRunForStream
+      .mockResolvedValueOnce({
+        status: 'active',
+        executionId: 'exec-1',
+        id: 'run-1',
+      })
+      .mockResolvedValueOnce(null)
+
+    const response = await GET(
+      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0')
+    )
 
-    const first = await reader!.read()
-    expect(first.done).toBe(true)
-    expect(getStreamMeta).toHaveBeenCalledTimes(2)
+    const chunks = await readAllChunks(response)
+    const body = chunks.join('')
+    expect(body).toContain(`"type":"${MothershipStreamV1EventType.error}"`)
+    expect(body).toContain('"code":"resume_run_unavailable"')
+    expect(body).toContain(`"type":"${MothershipStreamV1EventType.complete}"`)
   })
 })
diff --git a/apps/sim/app/api/copilot/chat/stream/route.ts b/apps/sim/app/api/copilot/chat/stream/route.ts
index b56d9471817..9ccf07b3994 100644
--- a/apps/sim/app/api/copilot/chat/stream/route.ts
+++ b/apps/sim/app/api/copilot/chat/stream/route.ts
@@ -1,12 +1,18 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
+import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
 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'
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+import {
+  checkForReplayGap,
+  createEvent,
+  encodeSSEEnvelope,
+  readEvents,
+  SSE_RESPONSE_HEADERS,
+} from '@/lib/copilot/request/session'
 
 export const maxDuration = 3600
 
@@ -14,8 +20,59 @@ const logger = createLogger('CopilotChatStreamAPI')
 const POLL_INTERVAL_MS = 250
 const MAX_STREAM_MS = 60 * 60 * 1000
 
-function encodeEvent(event: Record<string, any>): Uint8Array {
-  return new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`)
+function isTerminalStatus(
+  status: string | null | undefined
+): status is MothershipStreamV1CompletionStatus {
+  return (
+    status === MothershipStreamV1CompletionStatus.complete ||
+    status === MothershipStreamV1CompletionStatus.error ||
+    status === MothershipStreamV1CompletionStatus.cancelled
+  )
+}
+
+function buildResumeTerminalEnvelopes(options: {
+  streamId: string
+  afterCursor: string
+  status: MothershipStreamV1CompletionStatus
+  message?: string
+  code: string
+  reason?: string
+}) {
+  const baseSeq = Number(options.afterCursor || '0')
+  const seq = Number.isFinite(baseSeq) ? baseSeq : 0
+  const envelopes: ReturnType<typeof createEvent>[] = []
+
+  if (options.status === MothershipStreamV1CompletionStatus.error) {
+    envelopes.push(
+      createEvent({
+        streamId: options.streamId,
+        cursor: String(seq + 1),
+        seq: seq + 1,
+        requestId: '',
+        type: MothershipStreamV1EventType.error,
+        payload: {
+          message: options.message || 'Stream recovery failed before completion.',
+          code: options.code,
+        },
+      })
+    )
+  }
+
+  envelopes.push(
+    createEvent({
+      streamId: options.streamId,
+      cursor: String(seq + envelopes.length + 1),
+      seq: seq + envelopes.length + 1,
+      requestId: '',
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: options.status,
+        ...(options.reason ? { reason: options.reason } : {}),
+      },
+    })
+  )
+
+  return envelopes
 }
 
 export async function GET(request: NextRequest) {
@@ -28,58 +85,49 @@ export async function GET(request: NextRequest) {
 
   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 afterCursor = url.searchParams.get('after') || ''
   const batchMode = url.searchParams.get('batch') === 'true'
-  const toParam = url.searchParams.get('to')
-  const toEventId = toParam ? Number(toParam) : undefined
-
-  const reqLogger = logger.withMetadata({ messageId: streamId || undefined })
-
-  reqLogger.info('[Resume] Received resume request', {
-    streamId: streamId || undefined,
-    fromEventId,
-    toEventId,
-    batchMode,
-  })
 
   if (!streamId) {
     return NextResponse.json({ error: 'streamId is required' }, { status: 400 })
   }
 
-  const meta = (await getStreamMeta(streamId)) as StreamMeta | null
-  reqLogger.info('[Resume] Stream lookup', {
+  const run = await getLatestRunForStream(streamId, authenticatedUserId).catch((err) => {
+    logger.warn('Failed to fetch latest run for stream', {
+      streamId,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return null
+  })
+  logger.info('[Resume] Stream lookup', {
     streamId,
-    fromEventId,
-    toEventId,
+    afterCursor,
     batchMode,
-    hasMeta: !!meta,
-    metaStatus: meta?.status,
+    hasRun: !!run,
+    runStatus: run?.status,
   })
-  if (!meta) {
+  if (!run) {
     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
-    reqLogger.info('[Resume] Batch response', {
+    const afterSeq = afterCursor || '0'
+    const events = await readEvents(streamId, afterSeq)
+    const batchEvents = events.map((envelope) => ({
+      eventId: envelope.seq,
+      streamId: envelope.stream.streamId,
+      event: envelope,
+    }))
+    logger.info('[Resume] Batch response', {
       streamId,
-      fromEventId,
-      toEventId,
-      eventCount: filteredEvents.length,
+      afterCursor: afterSeq,
+      eventCount: batchEvents.length,
+      runStatus: run.status,
     })
     return NextResponse.json({
       success: true,
-      events: filteredEvents,
-      status: meta.status,
-      executionId: meta.executionId,
-      runId: meta.runId,
+      events: batchEvents,
+      status: run.status,
     })
   }
 
@@ -87,9 +135,9 @@ export async function GET(request: NextRequest) {
 
   const stream = new ReadableStream({
     async start(controller) {
-      let lastEventId = Number.isFinite(fromEventId) ? fromEventId : 0
-      let latestMeta = meta
+      let cursor = afterCursor || '0'
       let controllerClosed = false
+      let sawTerminalEvent = false
 
       const closeController = () => {
         if (controllerClosed) return
@@ -97,14 +145,14 @@ export async function GET(request: NextRequest) {
         try {
           controller.close()
         } catch {
-          // Controller already closed by runtime/client - treat as normal.
+          // Controller already closed by runtime/client
         }
       }
 
-      const enqueueEvent = (payload: Record<string, any>) => {
+      const enqueueEvent = (payload: unknown) => {
         if (controllerClosed) return false
         try {
-          controller.enqueue(encodeEvent(payload))
+          controller.enqueue(encodeSSEEnvelope(payload))
           return true
         } catch {
           controllerClosed = true
@@ -118,47 +166,96 @@ export async function GET(request: NextRequest) {
       request.signal.addEventListener('abort', abortListener, { once: true })
 
       const flushEvents = async () => {
-        const events = await readStreamEvents(streamId, lastEventId)
+        const events = await readEvents(streamId, cursor)
         if (events.length > 0) {
-          reqLogger.info('[Resume] Flushing events', {
+          logger.info('[Resume] Flushing events', {
             streamId,
-            fromEventId: lastEventId,
+            afterCursor: cursor,
             eventCount: events.length,
           })
         }
-        for (const entry of events) {
-          lastEventId = entry.eventId
-          const payload = {
-            ...entry.event,
-            eventId: entry.eventId,
-            streamId: entry.streamId,
-            executionId: latestMeta?.executionId,
-            runId: latestMeta?.runId,
+        for (const envelope of events) {
+          cursor = envelope.stream.cursor ?? String(envelope.seq)
+          if (envelope.type === MothershipStreamV1EventType.complete) {
+            sawTerminalEvent = true
           }
-          if (!enqueueEvent(payload)) {
+          if (!enqueueEvent(envelope)) {
+            break
+          }
+        }
+      }
+
+      const emitTerminalIfMissing = (
+        status: MothershipStreamV1CompletionStatus,
+        options?: { message?: string; code: string; reason?: string }
+      ) => {
+        if (controllerClosed || sawTerminalEvent) {
+          return
+        }
+        for (const envelope of buildResumeTerminalEnvelopes({
+          streamId,
+          afterCursor: cursor,
+          status,
+          message: options?.message,
+          code: options?.code ?? 'resume_terminal',
+          reason: options?.reason,
+        })) {
+          cursor = envelope.stream.cursor ?? String(envelope.seq)
+          if (envelope.type === MothershipStreamV1EventType.complete) {
+            sawTerminalEvent = true
+          }
+          if (!enqueueEvent(envelope)) {
             break
           }
         }
       }
 
       try {
+        const gap = await checkForReplayGap(streamId, afterCursor)
+        if (gap) {
+          for (const envelope of gap.envelopes) {
+            enqueueEvent(envelope)
+          }
+          return
+        }
+
         await flushEvents()
 
         while (!controllerClosed && Date.now() - startTime < MAX_STREAM_MS) {
-          const currentMeta = await getStreamMeta(streamId)
-          if (!currentMeta) break
-          latestMeta = currentMeta
+          const currentRun = await getLatestRunForStream(streamId, authenticatedUserId).catch(
+            (err) => {
+              logger.warn('Failed to poll latest run for stream', {
+                streamId,
+                error: err instanceof Error ? err.message : String(err),
+              })
+              return null
+            }
+          )
+          if (!currentRun) {
+            emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
+              message: 'The stream could not be recovered because its run metadata is unavailable.',
+              code: 'resume_run_unavailable',
+              reason: 'run_unavailable',
+            })
+            break
+          }
 
           await flushEvents()
 
           if (controllerClosed) {
             break
           }
-          if (
-            currentMeta.status === 'complete' ||
-            currentMeta.status === 'error' ||
-            currentMeta.status === 'cancelled'
-          ) {
+          if (isTerminalStatus(currentRun.status)) {
+            emitTerminalIfMissing(currentRun.status, {
+              message:
+                currentRun.status === MothershipStreamV1CompletionStatus.error
+                  ? typeof currentRun.error === 'string'
+                    ? currentRun.error
+                    : 'The recovered stream ended with an error.'
+                  : undefined,
+              code: 'resume_terminal_status',
+              reason: 'terminal_status',
+            })
             break
           }
 
@@ -169,12 +266,24 @@ export async function GET(request: NextRequest) {
 
           await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
         }
+        if (!controllerClosed && Date.now() - startTime >= MAX_STREAM_MS) {
+          emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
+            message: 'The stream recovery timed out before completion.',
+            code: 'resume_timeout',
+            reason: 'timeout',
+          })
+        }
       } catch (error) {
         if (!controllerClosed && !request.signal.aborted) {
-          reqLogger.warn('Stream replay failed', {
+          logger.warn('Stream replay failed', {
             streamId,
             error: error instanceof Error ? error.message : String(error),
           })
+          emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
+            message: 'The stream replay failed before completion.',
+            code: 'resume_internal',
+            reason: 'stream_replay_failed',
+          })
         }
       } finally {
         request.signal.removeEventListener('abort', abortListener)
@@ -183,5 +292,5 @@ export async function GET(request: NextRequest) {
     },
   })
 
-  return new Response(stream, { headers: SSE_HEADERS })
+  return new Response(stream, { headers: SSE_RESPONSE_HEADERS })
 }
diff --git a/apps/sim/app/api/copilot/chat/update-messages/route.test.ts b/apps/sim/app/api/copilot/chat/update-messages/route.test.ts
index 0376005c283..512a05cfd84 100644
--- a/apps/sim/app/api/copilot/chat/update-messages/route.test.ts
+++ b/apps/sim/app/api/copilot/chat/update-messages/route.test.ts
@@ -327,7 +327,35 @@ describe('Copilot Chat Update Messages API Route', () => {
       })
 
       expect(mockSet).toHaveBeenCalledWith({
-        messages,
+        messages: [
+          {
+            id: 'msg-1',
+            role: 'user',
+            content: 'Hello',
+            timestamp: '2024-01-01T10:00:00.000Z',
+          },
+          {
+            id: 'msg-2',
+            role: 'assistant',
+            content: 'Hi there!',
+            timestamp: '2024-01-01T10:01:00.000Z',
+            contentBlocks: [
+              {
+                type: 'text',
+                content: 'Here is the weather information',
+              },
+              {
+                type: 'tool',
+                phase: 'call',
+                toolCall: {
+                  id: 'tool-1',
+                  name: 'get_weather',
+                  state: 'pending',
+                },
+              },
+            ],
+          },
+        ],
         updatedAt: expect.any(Date),
       })
     })
diff --git a/apps/sim/app/api/copilot/chat/update-messages/route.ts b/apps/sim/app/api/copilot/chat/update-messages/route.ts
index 574c2241ede..ee2dfee0bb7 100644
--- a/apps/sim/app/api/copilot/chat/update-messages/route.ts
+++ b/apps/sim/app/api/copilot/chat/update-messages/route.ts
@@ -4,15 +4,16 @@ import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
-import { COPILOT_MODES } from '@/lib/copilot/models'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import { normalizeMessage, type PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+import { COPILOT_MODES } from '@/lib/copilot/constants'
 import {
   authenticateCopilotRequestSessionOnly,
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 
 const logger = createLogger('CopilotChatUpdateAPI')
 
@@ -78,12 +79,15 @@ export async function POST(req: NextRequest) {
     }
 
     const { chatId, messages, planArtifact, config } = UpdateMessagesSchema.parse(body)
+    const normalizedMessages: PersistedMessage[] = messages.map((message) =>
+      normalizeMessage(message as Record<string, unknown>)
+    )
 
     // Debug: Log what we're about to save
-    const lastMsgParsed = messages[messages.length - 1]
+    const lastMsgParsed = normalizedMessages[normalizedMessages.length - 1]
     if (lastMsgParsed?.role === 'assistant') {
       logger.info(`[${tracker.requestId}] Parsed messages to save`, {
-        messageCount: messages.length,
+        messageCount: normalizedMessages.length,
         lastMsgId: lastMsgParsed.id,
         lastMsgContentLength: lastMsgParsed.content?.length || 0,
         lastMsgContentBlockCount: lastMsgParsed.contentBlocks?.length || 0,
@@ -99,8 +103,8 @@ export async function POST(req: NextRequest) {
     }
 
     // Update chat with new messages, plan artifact, and config
-    const updateData: Record<string, any> = {
-      messages: messages,
+    const updateData: Record<string, unknown> = {
+      messages: normalizedMessages,
       updatedAt: new Date(),
     }
 
@@ -116,14 +120,14 @@ export async function POST(req: NextRequest) {
 
     logger.info(`[${tracker.requestId}] Successfully updated chat`, {
       chatId,
-      newMessageCount: messages.length,
+      newMessageCount: normalizedMessages.length,
       hasPlanArtifact: !!planArtifact,
       hasConfig: !!config,
     })
 
     return NextResponse.json({
       success: true,
-      messageCount: messages.length,
+      messageCount: normalizedMessages.length,
     })
   } catch (error) {
     logger.error(`[${tracker.requestId}] Error updating chat messages:`, error)
diff --git a/apps/sim/app/api/copilot/chats/route.test.ts b/apps/sim/app/api/copilot/chats/route.test.ts
index 32088fe093a..3dbbf2791f8 100644
--- a/apps/sim/app/api/copilot/chats/route.test.ts
+++ b/apps/sim/app/api/copilot/chats/route.test.ts
@@ -66,7 +66,7 @@ vi.mock('drizzle-orm', () => ({
   sql: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly: mockAuthenticate,
   createUnauthorizedResponse: mockCreateUnauthorizedResponse,
   createInternalServerErrorResponse: mockCreateInternalServerErrorResponse,
diff --git a/apps/sim/app/api/copilot/chats/route.ts b/apps/sim/app/api/copilot/chats/route.ts
index 7010d84e92b..b0142c27f7b 100644
--- a/apps/sim/app/api/copilot/chats/route.ts
+++ b/apps/sim/app/api/copilot/chats/route.ts
@@ -4,14 +4,14 @@ import { createLogger } from '@sim/logger'
 import { and, desc, eq, isNull, or, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
+import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
+} from '@/lib/copilot/request/http'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -37,7 +37,7 @@ export async function GET(_request: NextRequest) {
         title: copilotChats.title,
         workflowId: copilotChats.workflowId,
         workspaceId: copilotChats.workspaceId,
-        conversationId: copilotChats.conversationId,
+        activeStreamId: copilotChats.conversationId,
         updatedAt: copilotChats.updatedAt,
       })
       .from(copilotChats)
diff --git a/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts b/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts
index 7fd68b4925e..fe4fb76f4d1 100644
--- a/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts
+++ b/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts
@@ -43,7 +43,7 @@ vi.mock('@/lib/workflows/utils', () => ({
   authorizeWorkflowByWorkspacePermission: mockAuthorize,
 }))
 
-vi.mock('@/lib/copilot/chat-lifecycle', () => ({
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
   getAccessibleCopilotChat: mockGetAccessibleCopilotChat,
 }))
 
diff --git a/apps/sim/app/api/copilot/checkpoints/revert/route.ts b/apps/sim/app/api/copilot/checkpoints/revert/route.ts
index dd73477f5ec..b49d21f3841 100644
--- a/apps/sim/app/api/copilot/checkpoints/revert/route.ts
+++ b/apps/sim/app/api/copilot/checkpoints/revert/route.ts
@@ -4,14 +4,14 @@ import { createLogger } from '@sim/logger'
 import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 import { isUuidV4 } from '@/executor/constants'
diff --git a/apps/sim/app/api/copilot/checkpoints/route.test.ts b/apps/sim/app/api/copilot/checkpoints/route.test.ts
index eedf688af37..e1b3a1f4e81 100644
--- a/apps/sim/app/api/copilot/checkpoints/route.test.ts
+++ b/apps/sim/app/api/copilot/checkpoints/route.test.ts
@@ -62,7 +62,7 @@ vi.mock('drizzle-orm', () => ({
   desc: vi.fn((field: unknown) => ({ field, type: 'desc' })),
 }))
 
-vi.mock('@/lib/copilot/chat-lifecycle', () => ({
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
   getAccessibleCopilotChat: mockGetAccessibleCopilotChat,
 }))
 
diff --git a/apps/sim/app/api/copilot/checkpoints/route.ts b/apps/sim/app/api/copilot/checkpoints/route.ts
index 58b4cde4bb2..c800e519542 100644
--- a/apps/sim/app/api/copilot/checkpoints/route.ts
+++ b/apps/sim/app/api/copilot/checkpoints/route.ts
@@ -4,14 +4,14 @@ import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 
 const logger = createLogger('WorkflowCheckpointsAPI')
diff --git a/apps/sim/app/api/copilot/confirm/route.test.ts b/apps/sim/app/api/copilot/confirm/route.test.ts
index 8570d637646..0b40d981e84 100644
--- a/apps/sim/app/api/copilot/confirm/route.test.ts
+++ b/apps/sim/app/api/copilot/confirm/route.test.ts
@@ -38,7 +38,7 @@ const {
   publishToolConfirmation: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
@@ -54,7 +54,7 @@ vi.mock('@/lib/copilot/async-runs/repository', () => ({
   completeAsyncToolCall,
 }))
 
-vi.mock('@/lib/copilot/orchestrator/persistence', () => ({
+vi.mock('@/lib/copilot/persistence/tool-confirm', () => ({
   publishToolConfirmation,
 }))
 
diff --git a/apps/sim/app/api/copilot/confirm/route.ts b/apps/sim/app/api/copilot/confirm/route.ts
index bf154487f05..7246381105a 100644
--- a/apps/sim/app/api/copilot/confirm/route.ts
+++ b/apps/sim/app/api/copilot/confirm/route.ts
@@ -1,13 +1,14 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
+import { ASYNC_TOOL_STATUS } from '@/lib/copilot/async-runs/lifecycle'
 import {
   completeAsyncToolCall,
   getAsyncToolCall,
   getRunSegment,
   upsertAsyncToolCall,
 } from '@/lib/copilot/async-runs/repository'
-import { publishToolConfirmation } from '@/lib/copilot/orchestrator/persistence'
+import { publishToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
@@ -16,7 +17,7 @@ import {
   createRequestTracker,
   createUnauthorizedResponse,
   type NotificationStatus,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 
 const logger = createLogger('CopilotConfirmAPI')
 
@@ -42,17 +43,17 @@ async function updateToolCallStatus(
   const toolCallId = existing.toolCallId
   const durableStatus =
     status === 'success'
-      ? 'completed'
+      ? ASYNC_TOOL_STATUS.completed
       : status === 'cancelled'
-        ? 'cancelled'
+        ? ASYNC_TOOL_STATUS.cancelled
         : status === 'error' || status === 'rejected'
-          ? 'failed'
-          : 'pending'
+          ? ASYNC_TOOL_STATUS.failed
+          : ASYNC_TOOL_STATUS.pending
   try {
     if (
-      durableStatus === 'completed' ||
-      durableStatus === 'failed' ||
-      durableStatus === 'cancelled'
+      durableStatus === ASYNC_TOOL_STATUS.completed ||
+      durableStatus === ASYNC_TOOL_STATUS.failed ||
+      durableStatus === ASYNC_TOOL_STATUS.cancelled
     ) {
       await completeAsyncToolCall({
         toolCallId,
@@ -107,13 +108,25 @@ export async function POST(req: NextRequest) {
 
     const body = await req.json()
     const { toolCallId, status, message, data } = ConfirmationSchema.parse(body)
-    const existing = await getAsyncToolCall(toolCallId).catch(() => null)
+    const existing = await getAsyncToolCall(toolCallId).catch((err) => {
+      logger.warn('Failed to fetch async tool call', {
+        toolCallId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return null
+    })
 
     if (!existing) {
       return createNotFoundResponse('Tool call not found')
     }
 
-    const run = await getRunSegment(existing.runId).catch(() => null)
+    const run = await getRunSegment(existing.runId).catch((err) => {
+      logger.warn('Failed to fetch run segment', {
+        runId: existing.runId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return null
+    })
     if (!run) {
       return createNotFoundResponse('Tool call run not found')
     }
diff --git a/apps/sim/app/api/copilot/credentials/route.ts b/apps/sim/app/api/copilot/credentials/route.ts
index 2f764429d74..82d031c9e64 100644
--- a/apps/sim/app/api/copilot/credentials/route.ts
+++ b/apps/sim/app/api/copilot/credentials/route.ts
@@ -1,5 +1,5 @@
 import { type NextRequest, NextResponse } from 'next/server'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
 import { routeExecution } from '@/lib/copilot/tools/server/router'
 
 /**
diff --git a/apps/sim/app/api/copilot/feedback/route.test.ts b/apps/sim/app/api/copilot/feedback/route.test.ts
index f74aecf77a7..3f3a28598a6 100644
--- a/apps/sim/app/api/copilot/feedback/route.test.ts
+++ b/apps/sim/app/api/copilot/feedback/route.test.ts
@@ -57,7 +57,7 @@ vi.mock('drizzle-orm', () => ({
   eq: vi.fn((field: unknown, value: unknown) => ({ field, value, type: 'eq' })),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly: mockAuthenticate,
   createUnauthorizedResponse: mockCreateUnauthorizedResponse,
   createBadRequestResponse: mockCreateBadRequestResponse,
diff --git a/apps/sim/app/api/copilot/feedback/route.ts b/apps/sim/app/api/copilot/feedback/route.ts
index 92abaa1c3e9..175bc995d50 100644
--- a/apps/sim/app/api/copilot/feedback/route.ts
+++ b/apps/sim/app/api/copilot/feedback/route.ts
@@ -10,7 +10,7 @@ import {
   createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { captureServerEvent } from '@/lib/posthog/server'
 
 const logger = createLogger('CopilotFeedbackAPI')
diff --git a/apps/sim/app/api/copilot/models/route.ts b/apps/sim/app/api/copilot/models/route.ts
index d1773797453..7e23e38df69 100644
--- a/apps/sim/app/api/copilot/models/route.ts
+++ b/apps/sim/app/api/copilot/models/route.ts
@@ -1,8 +1,14 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
-import type { AvailableModel } from '@/lib/copilot/types'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+
+interface AvailableModel {
+  id: string
+  friendlyName: string
+  provider: string
+}
+
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotModelsAPI')
diff --git a/apps/sim/app/api/copilot/stats/route.test.ts b/apps/sim/app/api/copilot/stats/route.test.ts
index 176a97eb371..ca6e97704f0 100644
--- a/apps/sim/app/api/copilot/stats/route.test.ts
+++ b/apps/sim/app/api/copilot/stats/route.test.ts
@@ -23,7 +23,7 @@ const {
   mockFetch: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly: mockAuthenticateCopilotRequestSessionOnly,
   createUnauthorizedResponse: mockCreateUnauthorizedResponse,
   createBadRequestResponse: mockCreateBadRequestResponse,
diff --git a/apps/sim/app/api/copilot/stats/route.ts b/apps/sim/app/api/copilot/stats/route.ts
index 493f6e4ec90..75ed6d096b1 100644
--- a/apps/sim/app/api/copilot/stats/route.ts
+++ b/apps/sim/app/api/copilot/stats/route.ts
@@ -7,7 +7,7 @@ import {
   createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { env } from '@/lib/core/config/env'
 
 const BodySchema = z.object({
diff --git a/apps/sim/app/api/copilot/training/examples/route.ts b/apps/sim/app/api/copilot/training/examples/route.ts
index 934ce256875..a9318940b91 100644
--- a/apps/sim/app/api/copilot/training/examples/route.ts
+++ b/apps/sim/app/api/copilot/training/examples/route.ts
@@ -4,7 +4,7 @@ import { z } from 'zod'
 import {
   authenticateCopilotRequestSessionOnly,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotTrainingExamplesAPI')
diff --git a/apps/sim/app/api/copilot/training/route.ts b/apps/sim/app/api/copilot/training/route.ts
index e6e58f59bb0..e30918b8212 100644
--- a/apps/sim/app/api/copilot/training/route.ts
+++ b/apps/sim/app/api/copilot/training/route.ts
@@ -4,7 +4,7 @@ import { z } from 'zod'
 import {
   authenticateCopilotRequestSessionOnly,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotTrainingAPI')
diff --git a/apps/sim/app/api/files/serve/[...path]/route.test.ts b/apps/sim/app/api/files/serve/[...path]/route.test.ts
index bc5b35647c0..3c0c1fa7f6c 100644
--- a/apps/sim/app/api/files/serve/[...path]/route.test.ts
+++ b/apps/sim/app/api/files/serve/[...path]/route.test.ts
@@ -75,6 +75,16 @@ vi.mock('@/lib/uploads/utils/file-utils', () => ({
 
 vi.mock('@/lib/uploads/setup.server', () => ({}))
 
+vi.mock('@/lib/execution/doc-vm', () => ({
+  generatePdfFromCode: vi.fn().mockResolvedValue(Buffer.from('%PDF-compiled')),
+  generateDocxFromCode: vi.fn().mockResolvedValue(Buffer.from('PK\x03\x04compiled')),
+  generatePptxFromCode: vi.fn().mockResolvedValue(Buffer.from('PK\x03\x04compiled')),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  parseWorkspaceFileKey: vi.fn().mockReturnValue(undefined),
+}))
+
 vi.mock('@/app/api/files/utils', () => ({
   FileNotFoundError,
   createFileResponse: mockCreateFileResponse,
diff --git a/apps/sim/app/api/files/serve/[...path]/route.ts b/apps/sim/app/api/files/serve/[...path]/route.ts
index bc14086395a..0f15198c328 100644
--- a/apps/sim/app/api/files/serve/[...path]/route.ts
+++ b/apps/sim/app/api/files/serve/[...path]/route.ts
@@ -4,7 +4,11 @@ import { createLogger } from '@sim/logger'
 import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
-import { generatePptxFromCode } from '@/lib/execution/pptx-vm'
+import {
+  generateDocxFromCode,
+  generatePdfFromCode,
+  generatePptxFromCode,
+} from '@/lib/execution/doc-vm'
 import { CopilotFiles, isUsingCloudStorage } from '@/lib/uploads'
 import type { StorageContext } from '@/lib/uploads/config'
 import { parseWorkspaceFileKey } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
@@ -22,47 +26,73 @@ import {
 const logger = createLogger('FilesServeAPI')
 
 const ZIP_MAGIC = Buffer.from([0x50, 0x4b, 0x03, 0x04])
+const PDF_MAGIC = Buffer.from([0x25, 0x50, 0x44, 0x46, 0x2d]) // %PDF-
+
+interface CompilableFormat {
+  magic: Buffer
+  compile: (code: string, workspaceId: string) => Promise<Buffer>
+  contentType: string
+}
+
+const COMPILABLE_FORMATS: Record<string, CompilableFormat> = {
+  '.pptx': {
+    magic: ZIP_MAGIC,
+    compile: generatePptxFromCode,
+    contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  },
+  '.docx': {
+    magic: ZIP_MAGIC,
+    compile: generateDocxFromCode,
+    contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  },
+  '.pdf': {
+    magic: PDF_MAGIC,
+    compile: generatePdfFromCode,
+    contentType: 'application/pdf',
+  },
+}
 
-const MAX_COMPILED_PPTX_CACHE = 10
-const compiledPptxCache = new Map<string, Buffer>()
+const MAX_COMPILED_DOC_CACHE = 10
+const compiledDocCache = new Map<string, Buffer>()
 
 function compiledCacheSet(key: string, buffer: Buffer): void {
-  if (compiledPptxCache.size >= MAX_COMPILED_PPTX_CACHE) {
-    compiledPptxCache.delete(compiledPptxCache.keys().next().value as string)
+  if (compiledDocCache.size >= MAX_COMPILED_DOC_CACHE) {
+    compiledDocCache.delete(compiledDocCache.keys().next().value as string)
   }
-  compiledPptxCache.set(key, buffer)
+  compiledDocCache.set(key, buffer)
 }
 
-async function compilePptxIfNeeded(
+async function compileDocumentIfNeeded(
   buffer: Buffer,
   filename: string,
   workspaceId?: string,
   raw?: boolean
 ): Promise<{ buffer: Buffer; contentType: string }> {
-  const isPptx = filename.toLowerCase().endsWith('.pptx')
-  if (raw || !isPptx || buffer.subarray(0, 4).equals(ZIP_MAGIC)) {
+  if (raw) return { buffer, contentType: getContentType(filename) }
+
+  const ext = filename.slice(filename.lastIndexOf('.')).toLowerCase()
+  const format = COMPILABLE_FORMATS[ext]
+  if (!format) return { buffer, contentType: getContentType(filename) }
+
+  const magicLen = format.magic.length
+  if (buffer.length >= magicLen && buffer.subarray(0, magicLen).equals(format.magic)) {
     return { buffer, contentType: getContentType(filename) }
   }
 
   const code = buffer.toString('utf-8')
   const cacheKey = createHash('sha256')
+    .update(ext)
     .update(code)
     .update(workspaceId ?? '')
     .digest('hex')
-  const cached = compiledPptxCache.get(cacheKey)
+  const cached = compiledDocCache.get(cacheKey)
   if (cached) {
-    return {
-      buffer: cached,
-      contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-    }
+    return { buffer: cached, contentType: format.contentType }
   }
 
-  const compiled = await generatePptxFromCode(code, workspaceId || '')
+  const compiled = await format.compile(code, workspaceId || '')
   compiledCacheSet(cacheKey, compiled)
-  return {
-    buffer: compiled,
-    contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  }
+  return { buffer: compiled, contentType: format.contentType }
 }
 
 const STORAGE_KEY_PREFIX_RE = /^\d{13}-[a-z0-9]{7}-/
@@ -169,7 +199,7 @@ async function handleLocalFile(
     const segment = filename.split('/').pop() || filename
     const displayName = stripStorageKeyPrefix(segment)
     const workspaceId = getWorkspaceIdForCompile(filename)
-    const { buffer: fileBuffer, contentType } = await compilePptxIfNeeded(
+    const { buffer: fileBuffer, contentType } = await compileDocumentIfNeeded(
       rawBuffer,
       displayName,
       workspaceId,
@@ -226,7 +256,7 @@ async function handleCloudProxy(
     const segment = cloudKey.split('/').pop() || 'download'
     const displayName = stripStorageKeyPrefix(segment)
     const workspaceId = getWorkspaceIdForCompile(cloudKey)
-    const { buffer: fileBuffer, contentType } = await compilePptxIfNeeded(
+    const { buffer: fileBuffer, contentType } = await compileDocumentIfNeeded(
       rawBuffer,
       displayName,
       workspaceId,
diff --git a/apps/sim/app/api/function/execute/route.test.ts b/apps/sim/app/api/function/execute/route.test.ts
index 02db5236704..766bbb88fad 100644
--- a/apps/sim/app/api/function/execute/route.test.ts
+++ b/apps/sim/app/api/function/execute/route.test.ts
@@ -24,6 +24,27 @@ vi.mock('@/lib/auth/hybrid', () => ({
 
 vi.mock('@/lib/execution/e2b', () => ({
   executeInE2B: mockExecuteInE2B,
+  executeShellInE2B: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/tools/files', () => ({
+  FORMAT_TO_CONTENT_TYPE: {
+    json: 'application/json',
+    csv: 'text/csv',
+    txt: 'text/plain',
+    md: 'text/markdown',
+    html: 'text/html',
+  },
+  normalizeOutputWorkspaceFileName: vi.fn((p: string) => p.replace(/^files\//, '')),
+  resolveOutputFormat: vi.fn(() => 'json'),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  uploadWorkspaceFile: vi.fn(),
+}))
+
+vi.mock('@/lib/workflows/utils', () => ({
+  getWorkflowById: vi.fn(),
 }))
 
 vi.mock('@/lib/core/config/feature-flags', () => ({
@@ -32,6 +53,7 @@ vi.mock('@/lib/core/config/feature-flags', () => ({
   isProd: false,
   isDev: false,
   isTest: true,
+  isEmailVerificationEnabled: false,
 }))
 
 import { validateProxyUrl } from '@/lib/core/security/input-validation'
diff --git a/apps/sim/app/api/function/execute/route.ts b/apps/sim/app/api/function/execute/route.ts
index 24e992401b7..2328bf11fbb 100644
--- a/apps/sim/app/api/function/execute/route.ts
+++ b/apps/sim/app/api/function/execute/route.ts
@@ -1,11 +1,18 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { checkInternalAuth } from '@/lib/auth/hybrid'
+import {
+  FORMAT_TO_CONTENT_TYPE,
+  normalizeOutputWorkspaceFileName,
+  resolveOutputFormat,
+} from '@/lib/copilot/request/tools/files'
 import { isE2bEnabled } from '@/lib/core/config/feature-flags'
 import { generateRequestId } from '@/lib/core/utils/request'
-import { executeInE2B } from '@/lib/execution/e2b'
+import { executeInE2B, executeShellInE2B } from '@/lib/execution/e2b'
 import { executeInIsolatedVM } from '@/lib/execution/isolated-vm'
 import { CodeLanguage, DEFAULT_CODE_LANGUAGE, isValidCodeLanguage } from '@/lib/execution/languages'
+import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { getWorkflowById } from '@/lib/workflows/utils'
 import { escapeRegExp, normalizeName, REFERENCE } from '@/executor/constants'
 import { type OutputSchema, resolveBlockReference } from '@/executor/utils/block-reference'
 import { formatLiteralForCode } from '@/executor/utils/code-formatting'
@@ -580,6 +587,107 @@ function cleanStdout(stdout: string): string {
   return stdout
 }
 
+async function maybeExportSandboxFileToWorkspace(args: {
+  authUserId: string
+  workflowId?: string
+  workspaceId?: string
+  outputPath?: string
+  outputFormat?: string
+  outputMimeType?: string
+  outputSandboxPath?: string
+  exportedFileContent?: string
+  stdout: string
+  executionTime: number
+}) {
+  const {
+    authUserId,
+    workflowId,
+    workspaceId,
+    outputPath,
+    outputFormat,
+    outputMimeType,
+    outputSandboxPath,
+    exportedFileContent,
+    stdout,
+    executionTime,
+  } = args
+
+  if (!outputSandboxPath) return null
+
+  if (!outputPath) {
+    return NextResponse.json(
+      {
+        success: false,
+        error:
+          'outputSandboxPath requires outputPath. Set outputPath to the destination workspace file, e.g. "files/result.csv".',
+        output: { result: null, stdout: cleanStdout(stdout), executionTime },
+      },
+      { status: 400 }
+    )
+  }
+
+  const resolvedWorkspaceId =
+    workspaceId || (workflowId ? (await getWorkflowById(workflowId))?.workspaceId : undefined)
+
+  if (!resolvedWorkspaceId) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: 'Workspace context required to save sandbox file to workspace',
+        output: { result: null, stdout: cleanStdout(stdout), executionTime },
+      },
+      { status: 400 }
+    )
+  }
+
+  if (exportedFileContent === undefined) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: `Sandbox file "${outputSandboxPath}" was not found or could not be read`,
+        output: { result: null, stdout: cleanStdout(stdout), executionTime },
+      },
+      { status: 500 }
+    )
+  }
+
+  const fileName = normalizeOutputWorkspaceFileName(outputPath)
+
+  const TEXT_MIMES = new Set(Object.values(FORMAT_TO_CONTENT_TYPE))
+  const resolvedMimeType =
+    outputMimeType ||
+    FORMAT_TO_CONTENT_TYPE[resolveOutputFormat(fileName, outputFormat)] ||
+    'application/octet-stream'
+  const isBinary = !TEXT_MIMES.has(resolvedMimeType)
+  const fileBuffer = isBinary
+    ? Buffer.from(exportedFileContent, 'base64')
+    : Buffer.from(exportedFileContent, 'utf-8')
+
+  const uploaded = await uploadWorkspaceFile(
+    resolvedWorkspaceId,
+    authUserId,
+    fileBuffer,
+    fileName,
+    resolvedMimeType
+  )
+
+  return NextResponse.json({
+    success: true,
+    output: {
+      result: {
+        message: `Sandbox file exported to files/${fileName}`,
+        fileId: uploaded.id,
+        fileName,
+        downloadUrl: uploaded.url,
+        sandboxPath: outputSandboxPath,
+      },
+      stdout: cleanStdout(stdout),
+      executionTime,
+    },
+    resources: [{ type: 'file', id: uploaded.id, title: fileName }],
+  })
+}
+
 export async function POST(req: NextRequest) {
   const requestId = generateRequestId()
   const startTime = Date.now()
@@ -603,12 +711,17 @@ export async function POST(req: NextRequest) {
       params = {},
       timeout = DEFAULT_EXECUTION_TIMEOUT_MS,
       language = DEFAULT_CODE_LANGUAGE,
+      outputPath,
+      outputFormat,
+      outputMimeType,
+      outputSandboxPath,
       envVars = {},
       blockData = {},
       blockNameMapping = {},
       blockOutputSchemas = {},
       workflowVariables = {},
       workflowId,
+      workspaceId,
       isCustomTool = false,
       _sandboxFiles,
     } = body
@@ -626,18 +739,25 @@ export async function POST(req: NextRequest) {
 
     const lang = isValidCodeLanguage(language) ? language : DEFAULT_CODE_LANGUAGE
 
-    const codeResolution = resolveCodeVariables(
-      code,
-      executionParams,
-      envVars,
-      blockData,
-      blockNameMapping,
-      blockOutputSchemas,
-      workflowVariables,
-      lang
-    )
-    resolvedCode = codeResolution.resolvedCode
-    const contextVariables = codeResolution.contextVariables
+    let contextVariables: Record<string, unknown> = {}
+    if (lang === CodeLanguage.Shell) {
+      // For shell, env vars are injected as OS env vars via shellEnvs.
+      // Replace {{VAR}} placeholders with $VAR so the shell can access them natively.
+      resolvedCode = code.replace(/\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}/g, '$$$1')
+    } else {
+      const codeResolution = resolveCodeVariables(
+        code,
+        executionParams,
+        envVars,
+        blockData,
+        blockNameMapping,
+        blockOutputSchemas,
+        workflowVariables,
+        lang
+      )
+      resolvedCode = codeResolution.resolvedCode
+      contextVariables = codeResolution.contextVariables
+    }
 
     let jsImports = ''
     let jsRemainingCode = resolvedCode
@@ -652,6 +772,83 @@ export async function POST(req: NextRequest) {
       hasImports = jsImports.trim().length > 0 || hasRequireStatements
     }
 
+    if (lang === CodeLanguage.Shell) {
+      if (!isE2bEnabled) {
+        throw new Error(
+          'Shell execution requires E2B to be enabled. Please contact your administrator to enable E2B.'
+        )
+      }
+
+      const shellEnvs: Record<string, string> = {}
+      for (const [k, v] of Object.entries(envVars)) {
+        shellEnvs[k] = String(v)
+      }
+      for (const [k, v] of Object.entries(contextVariables)) {
+        shellEnvs[k] = String(v)
+      }
+
+      logger.info(`[${requestId}] E2B shell execution`, {
+        enabled: isE2bEnabled,
+        hasApiKey: Boolean(process.env.E2B_API_KEY),
+        envVarCount: Object.keys(shellEnvs).length,
+      })
+
+      const execStart = Date.now()
+      const {
+        result: shellResult,
+        stdout: shellStdout,
+        sandboxId,
+        error: shellError,
+        exportedFileContent,
+      } = await executeShellInE2B({
+        code: resolvedCode,
+        envs: shellEnvs,
+        timeoutMs: timeout,
+        sandboxFiles: _sandboxFiles,
+        outputSandboxPath,
+      })
+      const executionTime = Date.now() - execStart
+
+      logger.info(`[${requestId}] E2B shell sandbox`, {
+        sandboxId,
+        stdoutPreview: shellStdout?.slice(0, 200),
+        error: shellError,
+        executionTime,
+      })
+
+      if (shellError) {
+        return NextResponse.json(
+          {
+            success: false,
+            error: shellError,
+            output: { result: null, stdout: cleanStdout(shellStdout), executionTime },
+          },
+          { status: 500 }
+        )
+      }
+
+      if (outputSandboxPath) {
+        const fileExportResponse = await maybeExportSandboxFileToWorkspace({
+          authUserId: auth.userId,
+          workflowId,
+          workspaceId,
+          outputPath,
+          outputFormat,
+          outputMimeType,
+          outputSandboxPath,
+          exportedFileContent,
+          stdout: shellStdout,
+          executionTime,
+        })
+        if (fileExportResponse) return fileExportResponse
+      }
+
+      return NextResponse.json({
+        success: true,
+        output: { result: shellResult ?? null, stdout: cleanStdout(shellStdout), executionTime },
+      })
+    }
+
     if (lang === CodeLanguage.Python && !isE2bEnabled) {
       throw new Error(
         'Python execution requires E2B to be enabled. Please contact your administrator to enable E2B, or use JavaScript instead.'
@@ -719,11 +916,13 @@ export async function POST(req: NextRequest) {
           stdout: e2bStdout,
           sandboxId,
           error: e2bError,
+          exportedFileContent,
         } = await executeInE2B({
           code: codeForE2B,
           language: CodeLanguage.JavaScript,
           timeoutMs: timeout,
           sandboxFiles: _sandboxFiles,
+          outputSandboxPath,
         })
         const executionTime = Date.now() - execStart
         stdout += e2bStdout
@@ -752,6 +951,22 @@ export async function POST(req: NextRequest) {
           )
         }
 
+        if (outputSandboxPath) {
+          const fileExportResponse = await maybeExportSandboxFileToWorkspace({
+            authUserId: auth.userId,
+            workflowId,
+            workspaceId,
+            outputPath,
+            outputFormat,
+            outputMimeType,
+            outputSandboxPath,
+            exportedFileContent,
+            stdout,
+            executionTime,
+          })
+          if (fileExportResponse) return fileExportResponse
+        }
+
         return NextResponse.json({
           success: true,
           output: { result: e2bResult ?? null, stdout: cleanStdout(stdout), executionTime },
@@ -783,11 +998,13 @@ export async function POST(req: NextRequest) {
         stdout: e2bStdout,
         sandboxId,
         error: e2bError,
+        exportedFileContent,
       } = await executeInE2B({
         code: codeForE2B,
         language: CodeLanguage.Python,
         timeoutMs: timeout,
         sandboxFiles: _sandboxFiles,
+        outputSandboxPath,
       })
       const executionTime = Date.now() - execStart
       stdout += e2bStdout
@@ -816,6 +1033,22 @@ export async function POST(req: NextRequest) {
         )
       }
 
+      if (outputSandboxPath) {
+        const fileExportResponse = await maybeExportSandboxFileToWorkspace({
+          authUserId: auth.userId,
+          workflowId,
+          workspaceId,
+          outputPath,
+          outputFormat,
+          outputMimeType,
+          outputSandboxPath,
+          exportedFileContent,
+          stdout,
+          executionTime,
+        })
+        if (fileExportResponse) return fileExportResponse
+      }
+
       return NextResponse.json({
         success: true,
         output: { result: e2bResult ?? null, stdout: cleanStdout(stdout), executionTime },
diff --git a/apps/sim/app/api/mcp/copilot/route.ts b/apps/sim/app/api/mcp/copilot/route.ts
index f1377d5ad13..fca77e30cbb 100644
--- a/apps/sim/app/api/mcp/copilot/route.ts
+++ b/apps/sim/app/api/mcp/copilot/route.ts
@@ -17,14 +17,11 @@ import { eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { validateOAuthAccessToken } from '@/lib/auth/oauth-token'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
 import { ORCHESTRATION_TIMEOUT_MS, SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { orchestrateSubagentStream } from '@/lib/copilot/orchestrator/subagent'
-import {
-  executeToolServerSide,
-  prepareExecutionContext,
-} from '@/lib/copilot/orchestrator/tool-executor'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
+import { orchestrateSubagentStream } from '@/lib/copilot/request/subagent'
+import { ensureHandlersRegistered, executeTool } from '@/lib/copilot/tool-executor'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
 import { DIRECT_TOOL_DEFS, SUBAGENT_TOOL_DEFS } from '@/lib/copilot/tools/mcp/definitions'
 import { env } from '@/lib/core/config/env'
 import { RateLimiter } from '@/lib/core/rate-limiter'
@@ -125,12 +122,10 @@ Sim is a workflow automation platform. Workflows are visual pipelines of connect
 
 1. \`list_workspaces\` → know where to work
 2. \`create_workflow(name, workspaceId)\` → get a workflowId
-3. \`sim_build(request, workflowId)\` → plan and build in one pass
+3. \`sim_workflow(request, workflowId)\` → plan and build in one pass
 4. \`sim_test(request, workflowId)\` → verify it works
 5. \`sim_deploy("deploy as api", workflowId)\` → make it accessible externally (optional)
 
-For fine-grained control, use \`sim_plan\` → \`sim_edit\` instead of \`sim_build\`. Pass the plan object from sim_plan EXACTLY as-is to sim_edit's context.plan field.
-
 ### Working with Existing Workflows
 
 When the user refers to a workflow by name or description ("the email one", "my Slack bot"):
@@ -645,7 +640,8 @@ async function handleDirectToolCall(
       startTime: Date.now(),
     }
 
-    const result = await executeToolServerSide(toolCall, execContext)
+    ensureHandlersRegistered()
+    const result = await executeTool(toolCall.name, toolCall.params || {}, execContext)
 
     return {
       content: [
@@ -672,7 +668,7 @@ async function handleDirectToolCall(
 
 /**
  * Build mode uses the main chat orchestrator with the 'fast' command instead of
- * the subagent endpoint. In Go, 'build' is not a registered subagent — it's a mode
+ * the subagent endpoint. In Go, 'workflow' is not a registered subagent — it's a mode
  * (ModeFast) on the main chat processor that bypasses subagent orchestration and
  * executes all tools directly.
  */
@@ -728,25 +724,10 @@ async function handleBuildToolCall(
       chatId,
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-    const messageId = requestPayload.messageId as string
-
-    await createRunSegment({
-      id: runId,
-      executionId,
-      chatId,
-      userId,
-      workflowId: resolved.workflowId,
-      streamId: messageId,
-    }).catch(() => {})
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runCopilotLifecycle(requestPayload, {
       userId,
       workflowId: resolved.workflowId,
       chatId,
-      executionId,
-      runId,
       goRoute: '/api/mcp',
       autoExecuteTools: true,
       timeout: ORCHESTRATION_TIMEOUT_MS,
@@ -785,7 +766,7 @@ async function handleSubagentToolCall(
   userId: string,
   abortSignal?: AbortSignal
 ): Promise<CallToolResult> {
-  if (toolDef.agentId === 'build') {
+  if (toolDef.agentId === 'workflow') {
     return handleBuildToolCall(args, userId, abortSignal)
   }
 
diff --git a/apps/sim/app/api/mothership/chat/route.ts b/apps/sim/app/api/mothership/chat/route.ts
index 09dea73a050..d6275e33e74 100644
--- a/apps/sim/app/api/mothership/chat/route.ts
+++ b/apps/sim/app/api/mothership/chat/route.ts
@@ -5,19 +5,26 @@ import { eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getSession } from '@/lib/auth'
-import { resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
-import { buildCopilotRequestPayload } from '@/lib/copilot/chat-payload'
+import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
+import { buildCopilotRequestPayload } from '@/lib/copilot/chat/payload'
+import {
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import {
+  processContextsServer,
+  resolveActiveResourceContext,
+} from '@/lib/copilot/chat/process-contents'
+import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
+import { createRequestTracker, createUnauthorizedResponse } from '@/lib/copilot/request/http'
+import { createSSEStream, SSE_RESPONSE_HEADERS } from '@/lib/copilot/request/lifecycle/start'
 import {
   acquirePendingChatStream,
-  createSSEStream,
-  SSE_RESPONSE_HEADERS,
-} from '@/lib/copilot/chat-streaming'
-import type { OrchestratorResult } from '@/lib/copilot/orchestrator/types'
-import { processContextsServer, resolveActiveResourceContext } from '@/lib/copilot/process-contents'
-import { createRequestTracker, createUnauthorizedResponse } from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { generateWorkspaceContext } from '@/lib/copilot/workspace-context'
-import { generateId } from '@/lib/core/utils/uuid'
+  getPendingChatStreamId,
+  releasePendingChatStream,
+} from '@/lib/copilot/request/session'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import {
   assertActiveWorkspaceAccess,
   getUserEntityPermissions,
@@ -38,7 +45,6 @@ const FileAttachmentSchema = z.object({
 const ResourceAttachmentSchema = z.object({
   type: z.enum(['workflow', 'table', 'file', 'knowledgebase', 'folder']),
   id: z.string().min(1),
-  title: z.string().optional(),
   active: z.boolean().optional(),
 })
 
@@ -90,7 +96,9 @@ const MothershipMessageSchema = z.object({
  */
 export async function POST(req: NextRequest) {
   const tracker = createRequestTracker()
-  let userMessageIdForLogs: string | undefined
+  let lockChatId: string | undefined
+  let lockStreamId = ''
+  let chatStreamLockAcquired = false
 
   try {
     const session = await getSession()
@@ -112,28 +120,24 @@ export async function POST(req: NextRequest) {
       userTimezone,
     } = MothershipMessageSchema.parse(body)
 
-    const userMessageId = providedMessageId || generateId()
-    userMessageIdForLogs = userMessageId
-    const reqLogger = logger.withMetadata({
-      requestId: tracker.requestId,
-      messageId: userMessageId,
-    })
+    const userMessageId = providedMessageId || crypto.randomUUID()
+    lockStreamId = userMessageId
 
-    reqLogger.info('Received mothership chat start request', {
-      workspaceId,
-      chatId,
-      createNewChat,
-      hasContexts: Array.isArray(contexts) && contexts.length > 0,
-      contextsCount: Array.isArray(contexts) ? contexts.length : 0,
-      hasResourceAttachments: Array.isArray(resourceAttachments) && resourceAttachments.length > 0,
-      resourceAttachmentCount: Array.isArray(resourceAttachments) ? resourceAttachments.length : 0,
-      hasFileAttachments: Array.isArray(fileAttachments) && fileAttachments.length > 0,
-      fileAttachmentCount: Array.isArray(fileAttachments) ? fileAttachments.length : 0,
-    })
+    // Phase 1: workspace access + chat resolution in parallel
+    const [accessResult, chatResult] = await Promise.allSettled([
+      assertActiveWorkspaceAccess(workspaceId, authenticatedUserId),
+      chatId || createNewChat
+        ? resolveOrCreateChat({
+            chatId,
+            userId: authenticatedUserId,
+            workspaceId,
+            model: 'claude-opus-4-6',
+            type: 'mothership',
+          })
+        : null,
+    ])
 
-    try {
-      await assertActiveWorkspaceAccess(workspaceId, authenticatedUserId)
-    } catch {
+    if (accessResult.status === 'rejected') {
       return NextResponse.json({ error: 'Workspace not found or access denied' }, { status: 403 })
     }
 
@@ -141,18 +145,12 @@ export async function POST(req: NextRequest) {
     let conversationHistory: any[] = []
     let actualChatId = chatId
 
-    if (chatId || createNewChat) {
-      const chatResult = await resolveOrCreateChat({
-        chatId,
-        userId: authenticatedUserId,
-        workspaceId,
-        model: 'claude-opus-4-6',
-        type: 'mothership',
-      })
-      currentChat = chatResult.chat
-      actualChatId = chatResult.chatId || chatId
-      conversationHistory = Array.isArray(chatResult.conversationHistory)
-        ? chatResult.conversationHistory
+    if (chatResult.status === 'fulfilled' && chatResult.value) {
+      const resolved = chatResult.value
+      currentChat = resolved.chat
+      actualChatId = resolved.chatId || chatId
+      conversationHistory = Array.isArray(resolved.conversationHistory)
+        ? resolved.conversationHistory
         : []
 
       if (chatId && !currentChat) {
@@ -160,77 +158,73 @@ export async function POST(req: NextRequest) {
       }
     }
 
-    let agentContexts: Array<{ type: string; content: string }> = []
-    if (Array.isArray(contexts) && contexts.length > 0) {
-      try {
-        agentContexts = await processContextsServer(
-          contexts as any,
-          authenticatedUserId,
-          message,
-          workspaceId,
-          actualChatId
+    if (actualChatId) {
+      chatStreamLockAcquired = await acquirePendingChatStream(actualChatId, userMessageId)
+      if (!chatStreamLockAcquired) {
+        const activeStreamId = await getPendingChatStreamId(actualChatId)
+        return NextResponse.json(
+          {
+            error: 'A response is already in progress for this chat.',
+            ...(activeStreamId ? { activeStreamId } : {}),
+          },
+          { status: 409 }
         )
-      } catch (e) {
-        reqLogger.error('Failed to process contexts', e)
       }
+      lockChatId = actualChatId
     }
 
-    if (Array.isArray(resourceAttachments) && resourceAttachments.length > 0) {
-      const results = await Promise.allSettled(
-        resourceAttachments.map(async (r) => {
-          const ctx = await resolveActiveResourceContext(
-            r.type,
-            r.id,
-            workspaceId,
+    // Phase 2: contexts + workspace context + user message persistence in parallel
+    const contextPromise = (async () => {
+      let agentCtxs: Array<{ type: string; content: string }> = []
+      if (Array.isArray(contexts) && contexts.length > 0) {
+        try {
+          agentCtxs = await processContextsServer(
+            contexts as any,
             authenticatedUserId,
+            message,
+            workspaceId,
             actualChatId
           )
-          if (!ctx) return null
-          return {
-            ...ctx,
-            tag: r.active ? '@active_tab' : '@open_tab',
+        } catch (e) {
+          logger.error(`[${tracker.requestId}] Failed to process contexts`, e)
+        }
+      }
+      if (Array.isArray(resourceAttachments) && resourceAttachments.length > 0) {
+        const results = await Promise.allSettled(
+          resourceAttachments.map(async (r) => {
+            const ctx = await resolveActiveResourceContext(
+              r.type,
+              r.id,
+              workspaceId,
+              authenticatedUserId,
+              actualChatId
+            )
+            if (!ctx) return null
+            return { ...ctx, tag: r.active ? '@active_tab' : '@open_tab' }
+          })
+        )
+        for (const result of results) {
+          if (result.status === 'fulfilled' && result.value) {
+            agentCtxs.push(result.value)
+          } else if (result.status === 'rejected') {
+            logger.error(
+              `[${tracker.requestId}] Failed to resolve resource attachment`,
+              result.reason
+            )
           }
-        })
-      )
-      for (const result of results) {
-        if (result.status === 'fulfilled' && result.value) {
-          agentContexts.push(result.value)
-        } else if (result.status === 'rejected') {
-          reqLogger.error('Failed to resolve resource attachment', result.reason)
         }
       }
-    }
+      return agentCtxs
+    })()
 
-    if (actualChatId) {
-      const userMsg = {
+    const userMsgPromise = (async () => {
+      if (!actualChatId) return
+      const userMsg = buildPersistedUserMessage({
         id: userMessageId,
-        role: 'user' as const,
         content: message,
-        timestamp: new Date().toISOString(),
-        ...(fileAttachments &&
-          fileAttachments.length > 0 && {
-            fileAttachments: fileAttachments.map((f) => ({
-              id: f.id,
-              key: f.key,
-              filename: f.filename,
-              media_type: f.media_type,
-              size: f.size,
-            })),
-          }),
-        ...(contexts &&
-          contexts.length > 0 && {
-            contexts: contexts.map((c) => ({
-              kind: c.kind,
-              label: c.label,
-              ...(c.workflowId && { workflowId: c.workflowId }),
-              ...(c.knowledgeId && { knowledgeId: c.knowledgeId }),
-              ...(c.tableId && { tableId: c.tableId }),
-              ...(c.fileId && { fileId: c.fileId }),
-              ...(c.folderId && { folderId: c.folderId }),
-            })),
-          }),
-      }
-
+        fileAttachments,
+        contexts,
+      })
       const [updated] = await db
         .update(copilotChats)
         .set({
@@ -246,11 +240,15 @@ export async function POST(req: NextRequest) {
         conversationHistory = freshMessages.filter((m: any) => m.id !== userMessageId)
         taskPubSub?.publishStatusChanged({ workspaceId, chatId: actualChatId, type: 'started' })
       }
-    }
+    })()
 
-    const [workspaceContext, userPermission] = await Promise.all([
-      generateWorkspaceContext(workspaceId, authenticatedUserId),
-      getUserEntityPermissions(authenticatedUserId, 'workspace', workspaceId).catch(() => null),
+    const [agentContexts, [workspaceContext, userPermission]] = await Promise.all([
+      contextPromise,
+      Promise.all([
+        generateWorkspaceContext(workspaceId, authenticatedUserId),
+        getUserEntityPermissions(authenticatedUserId, 'workspace', workspaceId).catch(() => null),
+      ]),
+      userMsgPromise,
     ])
 
     const requestPayload = await buildCopilotRequestPayload(
@@ -271,21 +269,8 @@ export async function POST(req: NextRequest) {
       { selectedModel: '' }
     )
 
-    if (actualChatId) {
-      const acquired = await acquirePendingChatStream(actualChatId, userMessageId)
-      if (!acquired) {
-        return NextResponse.json(
-          {
-            error:
-              'A response is already in progress for this chat. Wait for it to finish or use Stop.',
-          },
-          { status: 409 }
-        )
-      }
-    }
-
-    const executionId = generateId()
-    const runId = generateId()
+    const executionId = crypto.randomUUID()
+    const runId = crypto.randomUUID()
     const stream = createSSEStream({
       requestPayload,
       userId: authenticatedUserId,
@@ -299,7 +284,6 @@ export async function POST(req: NextRequest) {
       titleModel: 'claude-opus-4-6',
       requestId: tracker.requestId,
       workspaceId,
-      pendingChatStreamAlreadyRegistered: Boolean(actualChatId),
       orchestrateOptions: {
         userId: authenticatedUserId,
         workspaceId,
@@ -313,46 +297,7 @@ export async function POST(req: NextRequest) {
           if (!actualChatId) return
           if (!result.success) return
 
-          const assistantMessage: Record<string, unknown> = {
-            id: generateId(),
-            role: 'assistant' as const,
-            content: result.content,
-            timestamp: new Date().toISOString(),
-            ...(result.requestId ? { requestId: result.requestId } : {}),
-          }
-          if (result.toolCalls.length > 0) {
-            assistantMessage.toolCalls = result.toolCalls
-          }
-          if (result.contentBlocks.length > 0) {
-            assistantMessage.contentBlocks = result.contentBlocks.map((block) => {
-              const stored: Record<string, unknown> = { type: block.type }
-              if (block.content) stored.content = block.content
-              if (block.type === 'tool_call' && block.toolCall) {
-                const state =
-                  block.toolCall.result?.success !== undefined
-                    ? block.toolCall.result.success
-                      ? 'success'
-                      : 'error'
-                    : block.toolCall.status
-                const isSubagentTool = !!block.calledBy
-                const isNonTerminal =
-                  state === 'cancelled' || state === 'pending' || state === 'executing'
-                stored.toolCall = {
-                  id: block.toolCall.id,
-                  name: block.toolCall.name,
-                  state,
-                  ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
-                  ...(isSubagentTool && isNonTerminal
-                    ? {}
-                    : block.toolCall.params
-                      ? { params: block.toolCall.params }
-                      : {}),
-                  ...(block.calledBy ? { calledBy: block.calledBy } : {}),
-                }
-              }
-              return stored
-            })
-          }
+          const assistantMessage = buildPersistedAssistantMessage(result, result.requestId)
 
           try {
             const [row] = await db
@@ -385,7 +330,7 @@ export async function POST(req: NextRequest) {
               })
             }
           } catch (error) {
-            reqLogger.error('Failed to persist chat messages', {
+            logger.error(`[${tracker.requestId}] Failed to persist chat messages`, {
               chatId: actualChatId,
               error: error instanceof Error ? error.message : 'Unknown error',
             })
@@ -396,6 +341,9 @@ export async function POST(req: NextRequest) {
 
     return new Response(stream, { headers: SSE_RESPONSE_HEADERS })
   } catch (error) {
+    if (chatStreamLockAcquired && lockChatId && lockStreamId) {
+      await releasePendingChatStream(lockChatId, lockStreamId)
+    }
     if (error instanceof z.ZodError) {
       return NextResponse.json(
         { error: 'Invalid request data', details: error.errors },
@@ -403,11 +351,9 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    logger
-      .withMetadata({ requestId: tracker.requestId, messageId: userMessageIdForLogs })
-      .error('Error handling mothership chat', {
-        error: error instanceof Error ? error.message : 'Unknown error',
-      })
+    logger.error(`[${tracker.requestId}] Error handling mothership chat:`, {
+      error: error instanceof Error ? error.message : 'Unknown error',
+    })
 
     return NextResponse.json(
       { error: error instanceof Error ? error.message : 'Internal server error' },
diff --git a/apps/sim/app/api/mothership/chat/stop/route.ts b/apps/sim/app/api/mothership/chat/stop/route.ts
index 70dc1df7c87..cc5cac32a29 100644
--- a/apps/sim/app/api/mothership/chat/stop/route.ts
+++ b/apps/sim/app/api/mothership/chat/stop/route.ts
@@ -5,9 +5,9 @@ import { and, eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getSession } from '@/lib/auth'
-import { releasePendingChatStream } from '@/lib/copilot/chat-streaming'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { generateId } from '@/lib/core/utils/uuid'
+import { normalizeMessage, type PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+import { releasePendingChatStream } from '@/lib/copilot/request/session'
+import { taskPubSub } from '@/lib/copilot/tasks'
 
 const logger = createLogger('MothershipChatStopAPI')
 
@@ -27,15 +27,25 @@ const StoredToolCallSchema = z
     display: z
       .object({
         text: z.string().optional(),
+        title: z.string().optional(),
+        phaseLabel: z.string().optional(),
       })
       .optional(),
     calledBy: z.string().optional(),
+    durationMs: z.number().optional(),
+    error: z.string().optional(),
   })
   .nullable()
 
 const ContentBlockSchema = z.object({
   type: z.string(),
+  lane: z.enum(['main', 'subagent']).optional(),
   content: z.string().optional(),
+  channel: z.enum(['assistant', 'thinking']).optional(),
+  phase: z.enum(['call', 'args_delta', 'result']).optional(),
+  kind: z.enum(['subagent', 'structured_result', 'subagent_result']).optional(),
+  lifecycle: z.enum(['start', 'end']).optional(),
+  status: z.enum(['complete', 'error', 'cancelled']).optional(),
   toolCall: StoredToolCallSchema.optional(),
 })
 
@@ -71,15 +81,14 @@ export async function POST(req: NextRequest) {
     const hasBlocks = Array.isArray(contentBlocks) && contentBlocks.length > 0
 
     if (hasContent || hasBlocks) {
-      const assistantMessage: Record<string, unknown> = {
-        id: generateId(),
-        role: 'assistant' as const,
+      const normalized = normalizeMessage({
+        id: crypto.randomUUID(),
+        role: 'assistant',
         content,
         timestamp: new Date().toISOString(),
-      }
-      if (hasBlocks) {
-        assistantMessage.contentBlocks = contentBlocks
-      }
+        ...(hasBlocks ? { contentBlocks } : {}),
+      })
+      const assistantMessage: PersistedMessage = normalized
       setClause.messages = sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`
     }
 
diff --git a/apps/sim/app/api/mothership/chats/[chatId]/route.ts b/apps/sim/app/api/mothership/chats/[chatId]/route.ts
index 3101e681589..5800507f9f1 100644
--- a/apps/sim/app/api/mothership/chats/[chatId]/route.ts
+++ b/apps/sim/app/api/mothership/chats/[chatId]/route.ts
@@ -4,15 +4,15 @@ import { createLogger } from '@sim/logger'
 import { and, eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
-import { getStreamMeta, readStreamEvents } from '@/lib/copilot/orchestrator/stream/buffer'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
+} from '@/lib/copilot/request/http'
+import { readEvents } from '@/lib/copilot/request/session/buffer'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { captureServerEvent } from '@/lib/posthog/server'
 
 const logger = createLogger('MothershipChatAPI')
@@ -47,29 +47,24 @@ export async function GET(
     }
 
     let streamSnapshot: {
-      events: Array<{ eventId: number; streamId: string; event: Record<string, unknown> }>
+      events: unknown[]
       status: string
     } | null = null
 
     if (chat.conversationId) {
       try {
-        const [meta, events] = await Promise.all([
-          getStreamMeta(chat.conversationId),
-          readStreamEvents(chat.conversationId, 0),
-        ])
+        const events = await readEvents(chat.conversationId, '0')
 
         streamSnapshot = {
           events: events || [],
-          status: meta?.status || 'unknown',
+          status: events.length > 0 ? 'active' : 'unknown',
         }
       } catch (error) {
-        logger
-          .withMetadata({ messageId: chat.conversationId || undefined })
-          .warn('Failed to read stream snapshot for mothership chat', {
-            chatId,
-            conversationId: chat.conversationId,
-            error: error instanceof Error ? error.message : String(error),
-          })
+        logger.warn('Failed to read stream snapshot for mothership chat', {
+          chatId,
+          conversationId: chat.conversationId,
+          error: error instanceof Error ? error.message : String(error),
+        })
       }
     }
 
diff --git a/apps/sim/app/api/mothership/chats/read/route.ts b/apps/sim/app/api/mothership/chats/read/route.ts
new file mode 100644
index 00000000000..344687ddfdc
--- /dev/null
+++ b/apps/sim/app/api/mothership/chats/read/route.ts
@@ -0,0 +1,43 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createBadRequestResponse,
+  createInternalServerErrorResponse,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request/http'
+
+const logger = createLogger('MarkTaskReadAPI')
+
+const MarkReadSchema = z.object({
+  chatId: z.string().min(1),
+})
+
+export async function POST(request: NextRequest) {
+  try {
+    const { userId, isAuthenticated } = await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !userId) {
+      return createUnauthorizedResponse()
+    }
+
+    const body = await request.json()
+    const { chatId } = MarkReadSchema.parse(body)
+
+    await db
+      .update(copilotChats)
+      .set({ lastSeenAt: sql`GREATEST(${copilotChats.updatedAt}, NOW())` })
+      .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, userId)))
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createBadRequestResponse('chatId is required')
+    }
+    logger.error('Error marking task as read:', error)
+    return createInternalServerErrorResponse('Failed to mark task as read')
+  }
+}
diff --git a/apps/sim/app/api/mothership/chats/route.ts b/apps/sim/app/api/mothership/chats/route.ts
index bc694d1d9fe..99bd6fd7390 100644
--- a/apps/sim/app/api/mothership/chats/route.ts
+++ b/apps/sim/app/api/mothership/chats/route.ts
@@ -9,8 +9,8 @@ import {
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
+} from '@/lib/copilot/request/http'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { captureServerEvent } from '@/lib/posthog/server'
 import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -39,7 +39,7 @@ export async function GET(request: NextRequest) {
         id: copilotChats.id,
         title: copilotChats.title,
         updatedAt: copilotChats.updatedAt,
-        conversationId: copilotChats.conversationId,
+        activeStreamId: copilotChats.conversationId,
         lastSeenAt: copilotChats.lastSeenAt,
       })
       .from(copilotChats)
diff --git a/apps/sim/app/api/mothership/events/route.ts b/apps/sim/app/api/mothership/events/route.ts
index 38abba7b33f..4f1646f6e34 100644
--- a/apps/sim/app/api/mothership/events/route.ts
+++ b/apps/sim/app/api/mothership/events/route.ts
@@ -7,7 +7,7 @@
  * Auth is handled via session cookies (EventSource sends cookies automatically).
  */
 
-import { taskPubSub } from '@/lib/copilot/task-events'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { createWorkspaceSSE } from '@/lib/events/sse-endpoint'
 
 export const dynamic = 'force-dynamic'
diff --git a/apps/sim/app/api/mothership/execute/route.ts b/apps/sim/app/api/mothership/execute/route.ts
index 619e0135726..06654a61b82 100644
--- a/apps/sim/app/api/mothership/execute/route.ts
+++ b/apps/sim/app/api/mothership/execute/route.ts
@@ -2,10 +2,9 @@ import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { checkInternalAuth } from '@/lib/auth/hybrid'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { buildIntegrationToolSchemas } from '@/lib/copilot/chat-payload'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { generateWorkspaceContext } from '@/lib/copilot/workspace-context'
+import { buildIntegrationToolSchemas } from '@/lib/copilot/chat/payload'
+import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
 import { generateId } from '@/lib/core/utils/uuid'
 import {
   assertActiveWorkspaceAccess,
@@ -73,34 +72,25 @@ export async function POST(req: NextRequest) {
       ...(userPermission ? { userPermission } : {}),
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-
-    await createRunSegment({
-      id: runId,
-      executionId,
-      chatId: effectiveChatId,
-      userId,
-      workspaceId,
-      streamId: messageId,
-    }).catch(() => {})
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runCopilotLifecycle(requestPayload, {
       userId,
       workspaceId,
       chatId: effectiveChatId,
-      executionId,
-      runId,
       goRoute: '/api/mothership/execute',
       autoExecuteTools: true,
       interactive: false,
     })
 
     if (!result.success) {
-      reqLogger.error('Mothership execute failed', {
-        error: result.error,
-        errors: result.errors,
-      })
+      logger.error(
+        messageId
+          ? `Mothership execute failed [messageId:${messageId}]`
+          : 'Mothership execute failed',
+        {
+          error: result.error,
+          errors: result.errors,
+        }
+      )
       return NextResponse.json(
         {
           error: result.error || 'Mothership execution failed',
@@ -136,9 +126,12 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    logger.withMetadata({ messageId }).error('Mothership execute error', {
-      error: error instanceof Error ? error.message : 'Unknown error',
-    })
+    logger.error(
+      messageId ? `Mothership execute error [messageId:${messageId}]` : 'Mothership execute error',
+      {
+        error: error instanceof Error ? error.message : 'Unknown error',
+      }
+    )
 
     return NextResponse.json(
       { error: error instanceof Error ? error.message : 'Internal server error' },
diff --git a/apps/sim/app/api/templates/approved/sanitized/route.ts b/apps/sim/app/api/templates/approved/sanitized/route.ts
index 2b6fad9652a..dd72ef80464 100644
--- a/apps/sim/app/api/templates/approved/sanitized/route.ts
+++ b/apps/sim/app/api/templates/approved/sanitized/route.ts
@@ -3,7 +3,7 @@ import { templates } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
-import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 
diff --git a/apps/sim/app/api/v1/copilot/chat/route.ts b/apps/sim/app/api/v1/copilot/chat/route.ts
index 52be435d681..5c366c91ff7 100644
--- a/apps/sim/app/api/v1/copilot/chat/route.ts
+++ b/apps/sim/app/api/v1/copilot/chat/route.ts
@@ -1,9 +1,8 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { COPILOT_REQUEST_MODES } from '@/lib/copilot/models'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
+import { COPILOT_REQUEST_MODES } from '@/lib/copilot/constants'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getWorkflowById, resolveWorkflowIdForUser } from '@/lib/workflows/utils'
 import { authenticateV1Request } from '@/app/api/v1/auth'
@@ -83,16 +82,20 @@ export async function POST(req: NextRequest) {
     // Always generate a chatId - required for artifacts system to work with subagents
     const chatId = parsed.chatId || generateId()
 
-    messageId = generateId()
-    const reqLogger = logger.withMetadata({ messageId })
-    reqLogger.info('Received headless copilot chat start request', {
-      workflowId: resolved.workflowId,
-      workflowName: parsed.workflowName,
-      chatId,
-      mode: transportMode,
-      autoExecuteTools: parsed.autoExecuteTools,
-      timeout: parsed.timeout,
-    })
+    messageId = crypto.randomUUID()
+    logger.info(
+      messageId
+        ? `Received headless copilot chat start request [messageId:${messageId}]`
+        : 'Received headless copilot chat start request',
+      {
+        workflowId: resolved.workflowId,
+        workflowName: parsed.workflowName,
+        chatId,
+        mode: transportMode,
+        autoExecuteTools: parsed.autoExecuteTools,
+        timeout: parsed.timeout,
+      }
+    )
     const requestPayload = {
       message: parsed.message,
       workflowId: resolved.workflowId,
@@ -103,24 +106,10 @@ export async function POST(req: NextRequest) {
       chatId,
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-
-    await createRunSegment({
-      id: runId,
-      executionId,
-      chatId,
-      userId: auth.userId,
-      workflowId: resolved.workflowId,
-      streamId: messageId,
-    }).catch(() => {})
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runCopilotLifecycle(requestPayload, {
       userId: auth.userId,
       workflowId: resolved.workflowId,
       chatId,
-      executionId,
-      runId,
       goRoute: '/api/mcp',
       autoExecuteTools: parsed.autoExecuteTools,
       timeout: parsed.timeout,
@@ -142,9 +131,14 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    logger.withMetadata({ messageId }).error('Headless copilot request failed', {
-      error: error instanceof Error ? error.message : String(error),
-    })
+    logger.error(
+      messageId
+        ? `Headless copilot request failed [messageId:${messageId}]`
+        : 'Headless copilot request failed',
+      {
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
     return NextResponse.json({ success: false, error: 'Internal server error' }, { status: 500 })
   }
 }
diff --git a/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts b/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts
index 65543049416..6de747246d8 100644
--- a/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts
+++ b/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts
@@ -1,7 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
-import { generatePptxFromCode } from '@/lib/execution/pptx-vm'
+import { generatePptxFromCode } from '@/lib/execution/doc-vm'
 import { verifyWorkspaceMembership } from '@/app/api/workflows/utils'
 
 export const dynamic = 'force-dynamic'
diff --git a/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx b/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx
index a450bd374da..cbed424d13b 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx
@@ -17,7 +17,7 @@ export function FileViewer() {
     return null
   }
 
-  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace`
+  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace&t=${file.size}`
 
   return (
     <div className='fixed inset-0 z-50 bg-[var(--bg)]'>
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
index f62caa1f51c..3235931ec74 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
@@ -57,7 +57,7 @@ const TEXT_EDITABLE_EXTENSIONS = new Set([
   ...SUPPORTED_CODE_EXTENSIONS,
 ])
 
-const IFRAME_PREVIEWABLE_MIME_TYPES = new Set(['application/pdf'])
+const IFRAME_PREVIEWABLE_MIME_TYPES = new Set(['application/pdf', 'text/x-pdflibjs'])
 const IFRAME_PREVIEWABLE_EXTENSIONS = new Set(['pdf'])
 
 const IMAGE_PREVIEWABLE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp'])
@@ -65,11 +65,13 @@ const IMAGE_PREVIEWABLE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp
 
 const PPTX_PREVIEWABLE_MIME_TYPES = new Set([
   'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  'text/x-pptxgenjs',
 ])
 const PPTX_PREVIEWABLE_EXTENSIONS = new Set(['pptx'])
 
 const DOCX_PREVIEWABLE_MIME_TYPES = new Set([
   'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  'text/x-docxjs',
 ])
 const DOCX_PREVIEWABLE_EXTENSIONS = new Set(['docx'])
 
@@ -91,8 +93,8 @@ function resolveFileCategory(mimeType: string | null, filename: string): FileCat
   if (mimeType && TEXT_EDITABLE_MIME_TYPES.has(mimeType)) return 'text-editable'
   if (mimeType && IFRAME_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'iframe-previewable'
   if (mimeType && IMAGE_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'image-previewable'
-  if (mimeType && PPTX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'pptx-previewable'
   if (mimeType && DOCX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'docx-previewable'
+  if (mimeType && PPTX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'pptx-previewable'
   if (mimeType && XLSX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'xlsx-previewable'
 
   const ext = getFileExtension(filename)
@@ -100,8 +102,8 @@ function resolveFileCategory(mimeType: string | null, filename: string): FileCat
   if (TEXT_EDITABLE_EXTENSIONS.has(nameKey)) return 'text-editable'
   if (IFRAME_PREVIEWABLE_EXTENSIONS.has(ext)) return 'iframe-previewable'
   if (IMAGE_PREVIEWABLE_EXTENSIONS.has(ext)) return 'image-previewable'
-  if (PPTX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'pptx-previewable'
   if (DOCX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'docx-previewable'
+  if (PPTX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'pptx-previewable'
   if (XLSX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'xlsx-previewable'
 
   return 'unsupported'
@@ -128,6 +130,7 @@ interface FileViewerProps {
   onSaveStatusChange?: (status: 'idle' | 'saving' | 'saved' | 'error') => void
   saveRef?: React.MutableRefObject<(() => Promise<void>) | null>
   streamingContent?: string
+  streamingMode?: 'append' | 'replace'
 }
 
 export function FileViewer({
@@ -141,6 +144,7 @@ export function FileViewer({
   onSaveStatusChange,
   saveRef,
   streamingContent,
+  streamingMode,
 }: FileViewerProps) {
   const category = resolveFileCategory(file.type, file.name)
 
@@ -156,26 +160,27 @@ export function FileViewer({
         onSaveStatusChange={onSaveStatusChange}
         saveRef={saveRef}
         streamingContent={streamingContent}
+        streamingMode={streamingMode}
       />
     )
   }
 
   if (category === 'iframe-previewable') {
-    return <IframePreview file={file} />
+    return <IframePreview file={file} workspaceId={workspaceId} />
   }
 
   if (category === 'image-previewable') {
     return <ImagePreview file={file} />
   }
 
-  if (category === 'pptx-previewable') {
-    return <PptxPreview file={file} workspaceId={workspaceId} streamingContent={streamingContent} />
-  }
-
   if (category === 'docx-previewable') {
     return <DocxPreview file={file} workspaceId={workspaceId} />
   }
 
+  if (category === 'pptx-previewable') {
+    return <PptxPreview file={file} workspaceId={workspaceId} streamingContent={streamingContent} />
+  }
+
   if (category === 'xlsx-previewable') {
     return <XlsxPreview file={file} workspaceId={workspaceId} />
   }
@@ -193,6 +198,7 @@ interface TextEditorProps {
   onSaveStatusChange?: (status: 'idle' | 'saving' | 'saved' | 'error') => void
   saveRef?: React.MutableRefObject<(() => Promise<void>) | null>
   streamingContent?: string
+  streamingMode?: 'append' | 'replace'
 }
 
 function TextEditor({
@@ -205,6 +211,7 @@ function TextEditor({
   onSaveStatusChange,
   saveRef,
   streamingContent,
+  streamingMode = 'append',
 }: TextEditorProps) {
   const initializedRef = useRef(false)
   const contentRef = useRef('')
@@ -219,7 +226,14 @@ function TextEditor({
     isLoading,
     error,
     dataUpdatedAt,
-  } = useWorkspaceFileContent(workspaceId, file.id, file.key, file.type === 'text/x-pptxgenjs')
+  } = useWorkspaceFileContent(
+    workspaceId,
+    file.id,
+    file.key,
+    file.type === 'text/x-pptxgenjs' ||
+      file.type === 'text/x-docxjs' ||
+      file.type === 'text/x-pdflibjs'
+  )
 
   const updateContent = useUpdateWorkspaceFileContent()
   const updateContentRef = useRef(updateContent)
@@ -228,15 +242,49 @@ function TextEditor({
   const [content, setContent] = useState('')
   const [savedContent, setSavedContent] = useState('')
   const savedContentRef = useRef('')
+  const wasStreamingRef = useRef(false)
+  const pendingStreamReconcileRef = useRef(false)
+  const lastStreamedContentRef = useRef<string | null>(null)
 
   useEffect(() => {
     if (streamingContent !== undefined) {
-      setContent(streamingContent)
-      contentRef.current = streamingContent
+      wasStreamingRef.current = true
+      const nextContent =
+        streamingMode === 'replace' || fetchedContent === undefined
+          ? streamingContent
+          : fetchedContent.endsWith(streamingContent) ||
+              fetchedContent.endsWith(`\n${streamingContent}`)
+            ? fetchedContent
+            : `${fetchedContent}\n${streamingContent}`
+      pendingStreamReconcileRef.current = true
+      lastStreamedContentRef.current = nextContent
+      setContent(nextContent)
+      contentRef.current = nextContent
       initializedRef.current = true
       return
     }
 
+    if (wasStreamingRef.current && pendingStreamReconcileRef.current) {
+      const lastStreamed = lastStreamedContentRef.current
+      const hasFetchedAdvanced =
+        fetchedContent !== undefined && fetchedContent !== savedContentRef.current
+      const fetchedMatchesLastStream =
+        fetchedContent !== undefined && lastStreamed !== null && fetchedContent === lastStreamed
+
+      if (hasFetchedAdvanced || fetchedMatchesLastStream) {
+        pendingStreamReconcileRef.current = false
+        wasStreamingRef.current = false
+        lastStreamedContentRef.current = null
+        if (lastStreamed !== null && contentRef.current === lastStreamed) {
+          setContent(fetchedContent)
+          contentRef.current = fetchedContent
+        }
+        setSavedContent(fetchedContent)
+        savedContentRef.current = fetchedContent
+        return
+      }
+    }
+
     if (fetchedContent === undefined) return
 
     if (!initializedRef.current) {
@@ -260,7 +308,7 @@ function TextEditor({
       savedContentRef.current = fetchedContent
       contentRef.current = fetchedContent
     }
-  }, [streamingContent, fetchedContent, dataUpdatedAt, autoFocus])
+  }, [streamingContent, fetchedContent, streamingMode, dataUpdatedAt, autoFocus])
 
   const handleContentChange = useCallback((value: string) => {
     setContent(value)
@@ -340,7 +388,8 @@ function TextEditor({
   )
 
   const isStreaming = streamingContent !== undefined
-  const revealedContent = useStreamingText(content, isStreaming)
+  const shouldAnimateStreaming = isStreaming && streamingMode === 'append'
+  const revealedContent = useStreamingText(content, shouldAnimateStreaming)
 
   const textareaStuckRef = useRef(true)
 
@@ -445,13 +494,36 @@ function TextEditor({
   )
 }
 
-const IframePreview = memo(function IframePreview({ file }: { file: WorkspaceFileRecord }) {
-  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace`
+const IframePreview = memo(function IframePreview({
+  file,
+  workspaceId,
+}: {
+  file: WorkspaceFileRecord
+  workspaceId: string
+}) {
+  const { data: fileData, isLoading } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
+  const [blobUrl, setBlobUrl] = useState<string | null>(null)
+
+  useEffect(() => {
+    if (!fileData) return
+    const blob = new Blob([fileData], { type: 'application/pdf' })
+    const url = URL.createObjectURL(blob)
+    setBlobUrl(url)
+    return () => URL.revokeObjectURL(url)
+  }, [fileData])
+
+  if (isLoading || !blobUrl) {
+    return (
+      <div className='flex h-full items-center justify-center'>
+        <Skeleton className='h-[200px] w-[80%]' />
+      </div>
+    )
+  }
 
   return (
     <div className='flex flex-1 overflow-hidden'>
       <iframe
-        src={serveUrl}
+        src={blobUrl}
         className='h-full w-full border-0'
         title={file.name}
         onError={() => {
@@ -470,7 +542,7 @@ const ZOOM_BUTTON_FACTOR = 1.2
 const clampZoom = (z: number) => Math.min(Math.max(z, ZOOM_MIN), ZOOM_MAX)
 
 const ImagePreview = memo(function ImagePreview({ file }: { file: WorkspaceFileRecord }) {
-  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace`
+  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace&t=${file.size}`
   const [zoom, setZoom] = useState(1)
   const [offset, setOffset] = useState({ x: 0, y: 0 })
   const isDragging = useRef(false)
@@ -603,6 +675,58 @@ const DOCUMENT_SKELETON = (
   </div>
 )
 
+const DocxPreview = memo(function DocxPreview({
+  file,
+  workspaceId,
+}: {
+  file: WorkspaceFileRecord
+  workspaceId: string
+}) {
+  const containerRef = useRef<HTMLDivElement>(null)
+  const {
+    data: fileData,
+    isLoading,
+    error: fetchError,
+  } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
+  const [renderError, setRenderError] = useState<string | null>(null)
+
+  useEffect(() => {
+    if (!containerRef.current || !fileData) return
+
+    let cancelled = false
+
+    async function render() {
+      try {
+        const { renderAsync } = await import('docx-preview')
+        if (cancelled || !containerRef.current) return
+        containerRef.current.innerHTML = ''
+        await renderAsync(fileData, containerRef.current, undefined, {
+          inWrapper: true,
+          ignoreWidth: false,
+          ignoreHeight: false,
+        })
+      } catch (err) {
+        if (!cancelled) {
+          const msg = err instanceof Error ? err.message : 'Failed to render document'
+          logger.error('DOCX render failed', { error: msg })
+          setRenderError(msg)
+        }
+      }
+    }
+
+    render()
+    return () => {
+      cancelled = true
+    }
+  }, [fileData])
+
+  const error = resolvePreviewError(fetchError, renderError)
+  if (error) return <PreviewError label='document' error={error} />
+  if (isLoading) return DOCUMENT_SKELETON
+
+  return <div ref={containerRef} className='h-full w-full overflow-auto bg-white' />
+})
+
 const pptxSlideCache = new Map<string, string[]>()
 
 function pptxCacheKey(fileId: string, dataUpdatedAt: number, byteLength: number): string {
@@ -865,77 +989,6 @@ function toggleMarkdownCheckbox(markdown: string, targetIndex: number, checked:
   })
 }
 
-const DocxPreview = memo(function DocxPreview({
-  file,
-  workspaceId,
-}: {
-  file: WorkspaceFileRecord
-  workspaceId: string
-}) {
-  const {
-    data: fileData,
-    isLoading,
-    error: fetchError,
-  } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
-
-  const [html, setHtml] = useState<string | null>(null)
-  const [renderError, setRenderError] = useState<string | null>(null)
-
-  useEffect(() => {
-    if (!fileData) return
-    const data = fileData
-
-    let cancelled = false
-
-    async function convert() {
-      try {
-        setRenderError(null)
-        const mammoth = await import('mammoth')
-        const result = await mammoth.convertToHtml({ arrayBuffer: data })
-        if (!cancelled) setHtml(result.value)
-      } catch (err) {
-        if (!cancelled) {
-          const msg = err instanceof Error ? err.message : 'Failed to render document'
-          logger.error('DOCX render failed', { error: msg })
-          setRenderError(msg)
-        }
-      }
-    }
-
-    convert()
-    return () => {
-      cancelled = true
-    }
-  }, [fileData])
-
-  const error = resolvePreviewError(fetchError, renderError)
-  if (error) return <PreviewError label='document' error={error} />
-  if (isLoading || html === null) return DOCUMENT_SKELETON
-
-  return (
-    <div className='flex flex-1 overflow-hidden'>
-      <iframe
-        srcDoc={buildDocxPreviewHtml(html)}
-        sandbox=''
-        title={file.name}
-        className='h-full w-full border-0'
-      />
-    </div>
-  )
-})
-
-/** Wraps mammoth HTML output with base styles. Uses raw hex colors because iframes cannot inherit CSS variables from the parent document. */
-function buildDocxPreviewHtml(html: string): string {
-  return `<!DOCTYPE html><html><head><style>
-body { margin: 0; padding: 24px; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 14px; line-height: 1.6; color: #e4e4e7; background: transparent; }
-table { border-collapse: collapse; width: 100%; margin: 12px 0; }
-td, th { border: 1px solid #3f3f46; padding: 6px 10px; }
-img { max-width: 100%; height: auto; }
-p { margin: 0 0 8px; }
-h1, h2, h3, h4, h5, h6 { margin: 16px 0 8px; }
-</style></head><body>${html}</body></html>`
-}
-
 const XLSX_MAX_ROWS = 1_000
 
 interface XlsxSheet {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
index 41a0011a81d..9de719a7f13 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
@@ -111,6 +111,7 @@ export function AgentGroup({
                     toolName={item.data.toolName}
                     displayTitle={item.data.displayTitle}
                     status={item.data.status}
+                    streamingArgs={item.data.streamingArgs}
                   />
                 ) : (
                   <span
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
index 05a91c3a364..b803b640060 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
@@ -1,4 +1,6 @@
+import { useMemo } from 'react'
 import { PillsRing } from '@/components/emcn'
+import { FunctionExecute, WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { ToolCallStatus } from '../../../../types'
 import { getToolIcon } from '../../utils'
 
@@ -54,19 +56,87 @@ function StatusIcon({ status, toolName }: { status: ToolCallStatus; toolName: st
   return <CircleCheck className='h-[15px] w-[15px] text-[var(--text-tertiary)]' />
 }
 
+const LANG_ALIASES: Record<string, string> = {
+  javascript: 'javascript',
+  python: 'python',
+  shell: 'bash',
+  bash: 'bash',
+}
+
+function extractFunctionExecutePreview(raw: string): { code: string; lang: string } | null {
+  if (!raw) return null
+  const langMatch = raw.match(/"language"\s*:\s*"(\w+)"/)
+  const lang = langMatch ? (LANG_ALIASES[langMatch[1]] ?? langMatch[1]) : 'javascript'
+
+  const codeStart = raw.indexOf('"code"')
+  if (codeStart === -1) return null
+  const colonIdx = raw.indexOf(':', codeStart + 6)
+  if (colonIdx === -1) return null
+  const quoteIdx = raw.indexOf('"', colonIdx + 1)
+  if (quoteIdx === -1) return null
+
+  let value = raw.slice(quoteIdx + 1)
+  if (value.endsWith('"}') || value.endsWith('"\n}')) {
+    value = value.replace(/"\s*\}?\s*$/, '')
+  }
+  if (value.endsWith('"')) {
+    value = value.slice(0, -1)
+  }
+
+  const code = value
+    .replace(/\\n/g, '\n')
+    .replace(/\\t/g, '\t')
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
+
+  return code.length > 0 ? { code, lang } : null
+}
+
 interface ToolCallItemProps {
   toolName: string
   displayTitle: string
   status: ToolCallStatus
+  streamingArgs?: string
 }
 
-export function ToolCallItem({ toolName, displayTitle, status }: ToolCallItemProps) {
+export function ToolCallItem({ toolName, displayTitle, status, streamingArgs }: ToolCallItemProps) {
+  const liveWorkspaceFileTitle = useMemo(() => {
+    if (toolName !== WorkspaceFile.id || !streamingArgs) return null
+    const titleMatch = streamingArgs.match(/"title"\s*:\s*"([^"]+)"/)
+    if (!titleMatch?.[1]) return null
+    const opMatch = streamingArgs.match(/"operation"\s*:\s*"(\w+)"/)
+    const op = opMatch?.[1] ?? ''
+    const verb =
+      op === 'patch' || op === 'update' || op === 'rename'
+        ? 'Editing'
+        : op === 'delete'
+          ? 'Deleting'
+          : 'Writing'
+    const unescaped = titleMatch[1]
+      .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex: string) =>
+        String.fromCharCode(Number.parseInt(hex, 16))
+      )
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, '\\')
+    return `${verb} ${unescaped}`
+  }, [toolName, streamingArgs])
+  const extracted = useMemo(() => {
+    if (toolName !== FunctionExecute.id || !streamingArgs) return null
+    return extractFunctionExecutePreview(streamingArgs)
+  }, [toolName, streamingArgs])
+  const markdown = useMemo(
+    () => (extracted ? `\`\`\`${extracted.lang}\n${extracted.code}\n\`\`\`` : null),
+    [extracted]
+  )
+
   return (
     <div className='flex items-center gap-[8px] pl-[24px]'>
       <div className='flex h-[16px] w-[16px] flex-shrink-0 items-center justify-center'>
         <StatusIcon status={status} toolName={toolName} />
       </div>
-      <span className='font-base text-[13px] text-[var(--text-secondary)]'>{displayTitle}</span>
+      <span className='font-base text-[13px] text-[var(--text-secondary)]'>
+        {liveWorkspaceFileTitle || displayTitle}
+      </span>
     </div>
   )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
index 83d19f44aa8..fe34d53fa64 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
@@ -1,21 +1,17 @@
 'use client'
 
-import type { AgentGroupItem } from '@/app/workspace/[workspaceId]/home/components/message-content/components'
 import {
-  AgentGroup,
-  ChatContent,
-  CircleStop,
-  Options,
-  PendingTagIndicator,
-} from '@/app/workspace/[workspaceId]/home/components/message-content/components'
-import type {
-  ContentBlock,
-  MothershipToolName,
-  OptionItem,
-  SubagentName,
-  ToolCallData,
-} from '@/app/workspace/[workspaceId]/home/types'
-import { SUBAGENT_LABELS, TOOL_UI_METADATA } from '@/app/workspace/[workspaceId]/home/types'
+  File as FileTool,
+  Read as ReadTool,
+  ToolSearchToolRegex,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import { resolveToolDisplay } from '@/lib/copilot/tools/client/store-utils'
+import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
+import type { ContentBlock, OptionItem, ToolCallData } from '../../types'
+import { SUBAGENT_LABELS, TOOL_UI_METADATA } from '../../types'
+import type { AgentGroupItem } from './components'
+import { AgentGroup, ChatContent, CircleStop, Options, PendingTagIndicator } from './components'
 
 interface TextSegment {
   type: 'text'
@@ -47,16 +43,29 @@ const SUBAGENT_KEYS = new Set(Object.keys(SUBAGENT_LABELS))
 
 /**
  * Maps subagent names to the Mothership tool that dispatches them when the
- * tool name differs from the subagent name (e.g. `workspace_file` → `file_write`).
+ * tool name differs from the subagent name (e.g. `workspace_file` → `file`).
  * When a `subagent` block arrives, any trailing dispatch tool in the previous
  * group is absorbed so it doesn't render as a separate Mothership entry.
  */
 const SUBAGENT_DISPATCH_TOOLS: Record<string, string> = {
-  file_write: 'workspace_file',
+  [FileTool.id]: WorkspaceFile.id,
+}
+
+function isToolResultRead(params?: Record<string, unknown>): boolean {
+  const path = params?.path
+  return typeof path === 'string' && path.startsWith('internal/tool-results/')
+}
+
+function formatToolName(name: string): string {
+  return name
+    .replace(/_v\d+$/, '')
+    .split('_')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ')
 }
 
 function resolveAgentLabel(key: string): string {
-  return SUBAGENT_LABELS[key as SubagentName] ?? key
+  return SUBAGENT_LABELS[key] ?? formatToolName(key)
 }
 
 function isToolDone(status: ToolCallData['status']): boolean {
@@ -67,12 +76,41 @@ function isDelegatingTool(tc: NonNullable<ContentBlock['toolCall']>): boolean {
   return tc.status === 'executing'
 }
 
+function mapToolStatusToClientState(
+  status: ContentBlock['toolCall'] extends { status: infer T } ? T : string
+) {
+  switch (status) {
+    case 'success':
+      return ClientToolCallState.success
+    case 'error':
+      return ClientToolCallState.error
+    case 'cancelled':
+      return ClientToolCallState.cancelled
+    default:
+      return ClientToolCallState.executing
+  }
+}
+
+function getOverrideDisplayTitle(tc: NonNullable<ContentBlock['toolCall']>): string | undefined {
+  if (tc.name === ReadTool.id || tc.name.endsWith('_respond')) {
+    return resolveToolDisplay(tc.name, mapToolStatusToClientState(tc.status), tc.id, tc.params)
+      ?.text
+  }
+  return undefined
+}
+
 function toToolData(tc: NonNullable<ContentBlock['toolCall']>): ToolCallData {
+  const overrideDisplayTitle = getOverrideDisplayTitle(tc)
+  const displayTitle =
+    overrideDisplayTitle ||
+    tc.displayTitle ||
+    TOOL_UI_METADATA[tc.name as keyof typeof TOOL_UI_METADATA]?.title ||
+    formatToolName(tc.name)
+
   return {
     id: tc.id,
     toolName: tc.name,
-    displayTitle:
-      tc.displayTitle ?? TOOL_UI_METADATA[tc.name as MothershipToolName]?.title ?? tc.name,
+    displayTitle,
     status: tc.status,
     params: tc.params,
     result: tc.result,
@@ -172,7 +210,8 @@ function parseBlocks(blocks: ContentBlock[]): MessageSegment[] {
     if (block.type === 'tool_call') {
       if (!block.toolCall) continue
       const tc = block.toolCall
-      if (tc.name === 'tool_search_tool_regex') continue
+      if (tc.name === ToolSearchToolRegex.id) continue
+      if (tc.name === ReadTool.id && isToolResultRead(tc.params)) continue
       const isDispatch = SUBAGENT_KEYS.has(tc.name) && !tc.calledBy
 
       if (isDispatch) {
@@ -312,7 +351,7 @@ export function MessageContent({
   if (segments.length === 0) {
     if (isStreaming) {
       return (
-        <div className='space-y-2.5'>
+        <div className='space-y-[10px]'>
           <PendingTagIndicator />
         </div>
       )
@@ -341,7 +380,7 @@ export function MessageContent({
     )?.id
 
   return (
-    <div className='space-y-2.5'>
+    <div className='space-y-[10px]'>
       {segments.map((segment, i) => {
         switch (segment.type) {
           case 'text':
@@ -384,9 +423,11 @@ export function MessageContent({
             )
           case 'stopped':
             return (
-              <div key={`stopped-${i}`} className='flex items-center gap-2'>
+              <div key={`stopped-${i}`} className='flex items-center gap-[8px]'>
                 <CircleStop className='h-[16px] w-[16px] flex-shrink-0 text-[var(--text-icon)]' />
-                <span className='font-base text-[var(--text-body)] text-sm'>Stopped by user</span>
+                <span className='font-base text-[14px] text-[var(--text-body)]'>
+                  Stopped by user
+                </span>
               </div>
             )
         }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
index 0c7807a576d..4c66041de28 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
@@ -4,7 +4,6 @@ import {
   Blimp,
   Bug,
   Calendar,
-  ClipboardList,
   Database,
   Eye,
   File,
@@ -23,106 +22,42 @@ import {
 } from '@/components/emcn'
 import { Table as TableIcon } from '@/components/emcn/icons'
 import { AgentIcon } from '@/components/icons'
-import type { MothershipToolName, SubagentName } from '@/app/workspace/[workspaceId]/home/types'
 
 export type IconComponent = ComponentType<SVGProps<SVGSVGElement>>
 
-const TOOL_ICONS: Record<MothershipToolName | SubagentName | 'mothership', IconComponent> = {
+const TOOL_ICONS: Record<string, IconComponent> = {
   mothership: Blimp,
-  // Workspace
   glob: FolderCode,
   grep: Search,
   read: File,
-  // Search
   search_online: Search,
   scrape_page: Search,
   get_page_contents: Search,
   search_library_docs: Library,
-  crawl_website: Search,
-  // Execution
+  manage_mcp_tool: Settings,
+  manage_skill: Asterisk,
+  user_memory: Database,
   function_execute: TerminalWindow,
   superagent: Blimp,
-  run_workflow: PlayOutline,
-  run_block: PlayOutline,
-  run_from_block: PlayOutline,
-  run_workflow_until_block: PlayOutline,
-  complete_job: PlayOutline,
-  get_execution_summary: ClipboardList,
-  get_job_logs: ClipboardList,
-  get_workflow_logs: ClipboardList,
-  get_workflow_data: Layout,
-  get_block_outputs: ClipboardList,
-  get_block_upstream_references: ClipboardList,
-  get_deployed_workflow_state: Rocket,
-  check_deployment_status: Rocket,
-  // Workflows & folders
+  user_table: TableIcon,
+  workspace_file: File,
   create_workflow: Layout,
-  delete_workflow: Layout,
   edit_workflow: Pencil,
-  rename_workflow: Pencil,
-  move_workflow: Layout,
-  create_folder: FolderCode,
-  delete_folder: FolderCode,
-  move_folder: FolderCode,
-  list_folders: FolderCode,
-  list_user_workspaces: Layout,
-  revert_to_version: Rocket,
-  get_deployment_version: Rocket,
-  open_resource: Eye,
-  // Files
-  workspace_file: File,
-  download_to_workspace_file: File,
-  materialize_file: File,
-  generate_image: File,
-  generate_visualization: File,
-  // Tables & knowledge
-  user_table: TableIcon,
-  knowledge_base: Database,
-  // Jobs
-  create_job: Calendar,
-  manage_job: Calendar,
-  update_job_history: Calendar,
-  job_respond: Calendar,
-  // Management
-  manage_mcp_tool: Settings,
-  manage_skill: Asterisk,
-  manage_credential: Integration,
-  manage_custom_tool: Wrench,
-  update_workspace_mcp_server: Settings,
-  delete_workspace_mcp_server: Settings,
-  create_workspace_mcp_server: Settings,
-  list_workspace_mcp_servers: Settings,
-  oauth_get_auth_link: Integration,
-  oauth_request_access: Integration,
-  set_environment_variables: Settings,
-  set_global_workflow_variables: Settings,
-  get_platform_actions: Settings,
-  search_documentation: Library,
-  search_patterns: Search,
-  deploy_api: Rocket,
-  deploy_chat: Rocket,
-  deploy_mcp: Rocket,
-  redeploy: Rocket,
-  generate_api_key: Asterisk,
-  user_memory: Database,
-  context_write: Pencil,
-  context_compaction: Asterisk,
-  // Subagents
-  build: Hammer,
+  workflow: Hammer,
   run: PlayOutline,
   deploy: Rocket,
   auth: Integration,
   knowledge: Database,
+  knowledge_base: Database,
   table: TableIcon,
   job: Calendar,
   agent: AgentIcon,
   custom_tool: Wrench,
   research: Search,
-  plan: ClipboardList,
   debug: Bug,
-  edit: Pencil,
-  fast_edit: Pencil,
-  file_write: File,
+  context_compaction: Asterisk,
+  open_resource: Eye,
+  file: File,
 }
 
 export function getAgentIcon(name: string): IconComponent {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
index ab2655ed48d..128ff6508d6 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
@@ -16,7 +16,7 @@ import {
   cancelRunToolExecution,
   markRunToolManuallyStopped,
   reportManualRunToolStop,
-} from '@/lib/copilot/client-sse/run-tool-execution'
+} from '@/lib/copilot/tools/client/run-tool-execution'
 import {
   downloadWorkspaceFile,
   getFileExtension,
@@ -46,7 +46,7 @@ import { useUsageLimits } from '@/app/workspace/[workspaceId]/w/[workflowId]/com
 import { useWorkflowExecution } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution'
 import { useFolders } from '@/hooks/queries/folders'
 import { useWorkflows } from '@/hooks/queries/workflows'
-import { useWorkspaceFiles } from '@/hooks/queries/workspace-files'
+import { useWorkspaceFileContent, useWorkspaceFiles } from '@/hooks/queries/workspace-files'
 import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
 import { useExecutionStore } from '@/stores/execution/store'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
@@ -65,7 +65,15 @@ interface ResourceContentProps {
   workspaceId: string
   resource: MothershipResource
   previewMode?: PreviewMode
-  streamingFile?: { fileName: string; content: string } | null
+  streamingFile?: {
+    toolCallId?: string
+    fileName: string
+    fileId?: string
+    targetKind?: 'new_file' | 'file_id'
+    operation?: string
+    edit?: Record<string, unknown>
+    content: string
+  } | null
   genericResourceData?: GenericResourceData
 }
 
@@ -84,14 +92,66 @@ export const ResourceContent = memo(function ResourceContent({
   genericResourceData,
 }: ResourceContentProps) {
   const streamFileName = streamingFile?.fileName || 'file.md'
-  const streamingExtractedContent = useMemo(() => {
+
+  const streamOperation = useMemo(() => {
     if (!streamingFile) return undefined
-    const extracted = extractFileContent(streamingFile.content)
-    return extracted.length > 0 ? extracted : undefined
+    return streamingFile.operation
   }, [streamingFile])
+
+  const isWriteStream = streamOperation === 'create' || streamOperation === 'append'
+  const isPatchStream = streamOperation === 'patch'
+  const isUpdateStream = streamOperation === 'update'
+
+  const { data: allFiles = [] } = useWorkspaceFiles(workspaceId)
+  const activeFileRecord = useMemo(() => {
+    if (!isPatchStream || resource.type !== 'file') return undefined
+    return allFiles.find((f) => f.id === resource.id)
+  }, [isPatchStream, resource, allFiles])
+
+  const isSourceMime =
+    activeFileRecord?.type === 'text/x-pptxgenjs' ||
+    activeFileRecord?.type === 'text/x-docxjs' ||
+    activeFileRecord?.type === 'text/x-pdflibjs'
+
+  const { data: fetchedFileContent } = useWorkspaceFileContent(
+    workspaceId,
+    activeFileRecord?.id ?? '',
+    activeFileRecord?.key ?? '',
+    isSourceMime
+  )
+
+  const streamingExtractedContent = useMemo(() => {
+    if (!streamingFile) return undefined
+    if (!streamOperation) return undefined
+
+    if (isPatchStream) {
+      if (!fetchedFileContent) return undefined
+      return extractPatchPreview(streamingFile, fetchedFileContent)
+    }
+
+    const extracted = streamingFile.content
+    if (extracted.length === 0) return undefined
+
+    if (isUpdateStream) return extracted
+    if (isWriteStream) return extracted
+
+    return undefined
+  }, [
+    streamingFile,
+    streamOperation,
+    isWriteStream,
+    isPatchStream,
+    isUpdateStream,
+    fetchedFileContent,
+  ])
   const syntheticFile = useMemo(() => {
     const ext = getFileExtension(streamFileName)
-    const type = ext === 'pptx' ? 'text/x-pptxgenjs' : getMimeTypeFromExtension(ext)
+    const SOURCE_MIME_MAP: Record<string, string> = {
+      pptx: 'text/x-pptxgenjs',
+      docx: 'text/x-docxjs',
+      pdf: 'text/x-pdflibjs',
+    }
+    const type = SOURCE_MIME_MAP[ext] ?? getMimeTypeFromExtension(ext)
     return {
       id: 'streaming-file',
       workspaceId,
@@ -105,6 +165,15 @@ export const ResourceContent = memo(function ResourceContent({
     }
   }, [workspaceId, streamFileName])
 
+  const streamingFileMode: 'append' | 'replace' = isWriteStream ? 'append' : 'replace'
+
+  // For existing file resources (not streaming-file), only pass streaming
+  // content for patch operations where the preview splices new content into
+  // the displayed file. Update operations re-stream the entire file from
+  // scratch which causes visual duplication of already-visible content.
+  const embeddedStreamingContent =
+    resource.id !== 'streaming-file' && isUpdateStream ? undefined : streamingExtractedContent
+
   if (streamingFile && resource.id === 'streaming-file') {
     return (
       <div className='flex h-full flex-col overflow-hidden'>
@@ -115,6 +184,7 @@ export const ResourceContent = memo(function ResourceContent({
             canEdit={false}
             previewMode={previewMode ?? 'preview'}
             streamingContent={streamingExtractedContent}
+            streamingMode={streamingFileMode}
           />
         ) : (
           <div className='flex h-full items-center justify-center'>
@@ -136,7 +206,8 @@ export const ResourceContent = memo(function ResourceContent({
           workspaceId={workspaceId}
           fileId={resource.id}
           previewMode={previewMode}
-          streamingContent={streamingExtractedContent}
+          streamingContent={embeddedStreamingContent}
+          streamingMode={streamingFileMode}
         />
       )
 
@@ -425,9 +496,16 @@ interface EmbeddedFileProps {
   fileId: string
   previewMode?: PreviewMode
   streamingContent?: string
+  streamingMode?: 'append' | 'replace'
 }
 
-function EmbeddedFile({ workspaceId, fileId, previewMode, streamingContent }: EmbeddedFileProps) {
+function EmbeddedFile({
+  workspaceId,
+  fileId,
+  previewMode,
+  streamingContent,
+  streamingMode,
+}: EmbeddedFileProps) {
   const { canEdit } = useUserPermissionsContext()
   const { data: files = [], isLoading, isFetching } = useWorkspaceFiles(workspaceId)
   const file = useMemo(() => files.find((f) => f.id === fileId), [files, fileId])
@@ -455,6 +533,7 @@ function EmbeddedFile({ workspaceId, fileId, previewMode, streamingContent }: Em
         file={file}
         workspaceId={workspaceId}
         canEdit={canEdit}
+        streamingMode={streamingMode}
         previewMode={previewMode}
         streamingContent={streamingContent}
       />
@@ -528,15 +607,94 @@ function EmbeddedFolder({ workspaceId, folderId }: EmbeddedFolderProps) {
   )
 }
 
-function extractFileContent(raw: string): string {
-  const marker = '"content":'
-  const idx = raw.indexOf(marker)
-  if (idx === -1) return ''
-  let rest = raw.slice(idx + marker.length).trimStart()
-  if (rest.startsWith('"')) rest = rest.slice(1)
-  return rest
-    .replace(/\\n/g, '\n')
-    .replace(/\\t/g, '\t')
-    .replace(/\\"/g, '"')
-    .replace(/\\\\/g, '\\')
+function findAnchorIndex(lines: string[], anchor: string, occurrence = 1, afterIndex = -1): number {
+  const trimmed = anchor.trim()
+  let count = 0
+  for (let i = afterIndex + 1; i < lines.length; i++) {
+    if (lines[i].trim() === trimmed) {
+      count++
+      if (count === occurrence) return i
+    }
+  }
+  return -1
+}
+
+function extractPatchPreview(
+  streamingFile: {
+    content: string
+    edit?: Record<string, unknown>
+  },
+  existingContent: string
+): string | undefined {
+  const edit = streamingFile.edit ?? {}
+  const strategy = typeof edit.strategy === 'string' ? edit.strategy : undefined
+  const lines = existingContent.split('\n')
+  const occurrence =
+    typeof edit.occurrence === 'number' && Number.isFinite(edit.occurrence) ? edit.occurrence : 1
+
+  if (strategy === 'search_replace') {
+    const search = typeof edit.search === 'string' ? edit.search : ''
+    if (!search) return undefined
+    const replace = streamingFile.content
+    if ((edit.replaceAll as boolean | undefined) === true) {
+      return existingContent.split(search).join(replace)
+    }
+    const firstIdx = existingContent.indexOf(search)
+    if (firstIdx === -1) return undefined
+    return (
+      existingContent.slice(0, firstIdx) + replace + existingContent.slice(firstIdx + search.length)
+    )
+  }
+
+  const mode = typeof edit.mode === 'string' ? edit.mode : undefined
+  if (!mode) return undefined
+
+  if (mode === 'replace_between') {
+    const beforeAnchor = typeof edit.before_anchor === 'string' ? edit.before_anchor : undefined
+    const afterAnchor = typeof edit.after_anchor === 'string' ? edit.after_anchor : undefined
+    if (!beforeAnchor || !afterAnchor) return undefined
+
+    const beforeIdx = findAnchorIndex(lines, beforeAnchor, occurrence)
+    const afterIdx = findAnchorIndex(lines, afterAnchor, occurrence, beforeIdx)
+    if (beforeIdx === -1 || afterIdx === -1 || afterIdx <= beforeIdx) return undefined
+
+    const newContent = streamingFile.content
+    const spliced = [
+      ...lines.slice(0, beforeIdx + 1),
+      ...(newContent.length > 0 ? newContent.split('\n') : []),
+      ...lines.slice(afterIdx),
+    ]
+    return spliced.join('\n')
+  }
+
+  if (mode === 'insert_after') {
+    const anchor = typeof edit.anchor === 'string' ? edit.anchor : undefined
+    if (!anchor) return undefined
+
+    const anchorIdx = findAnchorIndex(lines, anchor, occurrence)
+    if (anchorIdx === -1) return undefined
+
+    const newContent = streamingFile.content
+    const spliced = [
+      ...lines.slice(0, anchorIdx + 1),
+      ...(newContent.length > 0 ? newContent.split('\n') : []),
+      ...lines.slice(anchorIdx + 1),
+    ]
+    return spliced.join('\n')
+  }
+
+  if (mode === 'delete_between') {
+    const startAnchor = typeof edit.start_anchor === 'string' ? edit.start_anchor : undefined
+    const endAnchor = typeof edit.end_anchor === 'string' ? edit.end_anchor : undefined
+    if (!startAnchor || !endAnchor) return undefined
+
+    const startIdx = findAnchorIndex(lines, startAnchor, occurrence)
+    const endIdx = findAnchorIndex(lines, endAnchor, occurrence, startIdx)
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return undefined
+
+    const spliced = [...lines.slice(0, startIdx), ...lines.slice(endIdx)]
+    return spliced.join('\n')
+  }
+
+  return undefined
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
index 2809070fde2..576054d08ee 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
@@ -9,8 +9,8 @@ import {
 } from 'react'
 import { Button, Tooltip } from '@/components/emcn'
 import { Columns3, Eye, PanelLeft, Pencil } from '@/components/emcn/icons'
-import { isEphemeralResource } from '@/lib/copilot/resource-extraction'
 import { SIM_RESOURCE_DRAG_TYPE } from '@/lib/copilot/resource-types'
+import { isEphemeralResource } from '@/lib/copilot/resources/types'
 import { cn } from '@/lib/core/utils/cn'
 import type { PreviewMode } from '@/app/workspace/[workspaceId]/files/components/file-viewer'
 import { AddResourceDropdown } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/add-resource-dropdown'
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
index d2d72250261..ad85354ac56 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
@@ -19,37 +19,30 @@ const PREVIEW_CYCLE: Record<PreviewMode, PreviewMode> = {
   preview: 'editor',
 } as const
 
-function streamFileBasename(name: string): string {
-  const n = name.replace(/\\/g, '/').trim()
-  const parts = n.split('/').filter(Boolean)
-  return parts.length ? parts[parts.length - 1]! : n
-}
-
-function fileTitlesEquivalent(streamFileName: string, resourceTitle: string): boolean {
-  return streamFileBasename(streamFileName) === streamFileBasename(resourceTitle)
-}
-
 /**
- * Whether the active resource should show the in-progress file_write stream.
- * The synthetic `streaming-file` tab always shows it; a real file tab shows it when
- * the streamed `fileName` matches that resource (so users who stay on the open file see live text).
+ * Whether the active resource should show the in-progress file stream.
+ * The synthetic `streaming-file` tab always shows it; a real file tab only shows it
+ * when the streamed fileId matches that exact resource.
  */
-function streamReferencesFileId(raw: string, fileId: string): boolean {
-  if (!fileId) return false
-  const escaped = fileId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return new RegExp(`"fileId"\\s*:\\s*"${escaped}"`).test(raw)
-}
-
 function shouldShowStreamingFilePanel(
-  streamingFile: { fileName: string; content: string } | null | undefined,
+  streamingFile:
+    | {
+        toolCallId?: string
+        fileName: string
+        fileId?: string
+        targetKind?: 'new_file' | 'file_id'
+        operation?: string
+        edit?: Record<string, unknown>
+        content: string
+      }
+    | null
+    | undefined,
   active: MothershipResource | null
 ): boolean {
   if (!streamingFile || !active) return false
   if (active.id === 'streaming-file') return true
   if (active.type !== 'file') return false
-  const fn = streamingFile.fileName.trim()
-  if (fn && fileTitlesEquivalent(fn, active.title)) return true
-  if (active.id && streamReferencesFileId(streamingFile.content, active.id)) return true
+  if (active.id && streamingFile.fileId === active.id) return true
   return false
 }
 
@@ -65,7 +58,15 @@ interface MothershipViewProps {
   onCollapse: () => void
   isCollapsed: boolean
   className?: string
-  streamingFile?: { fileName: string; content: string } | null
+  streamingFile?: {
+    toolCallId?: string
+    fileName: string
+    fileId?: string
+    targetKind?: 'new_file' | 'file_id'
+    operation?: string
+    edit?: Record<string, unknown>
+    content: string
+  } | null
   genericResourceData?: GenericResourceData
 }
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx
index 3778f8fd1cf..d4a3ea7c7c1 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx
@@ -65,14 +65,16 @@ function MentionHighlight({ context }: { context: ChatMessageContext }) {
 }
 
 export function UserMessageContent({ content, contexts }: UserMessageContentProps) {
+  const trimmed = content.trim()
+
   if (!contexts || contexts.length === 0) {
-    return <p className={USER_MESSAGE_CLASSES}>{content}</p>
+    return <p className={USER_MESSAGE_CLASSES}>{trimmed}</p>
   }
 
   const ranges = computeMentionRanges(content, contexts)
 
   if (ranges.length === 0) {
-    return <p className={USER_MESSAGE_CLASSES}>{content}</p>
+    return <p className={USER_MESSAGE_CLASSES}>{trimmed}</p>
   }
 
   const elements: React.ReactNode[] = []
diff --git a/apps/sim/app/workspace/[workspaceId]/home/home.tsx b/apps/sim/app/workspace/[workspaceId]/home/home.tsx
index 132d87b2a9e..17094e446ad 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/home.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/home.tsx
@@ -402,7 +402,7 @@ export function Home({ chatId }: HomeProps = {}) {
         onCollapse={collapseResource}
         isCollapsed={isResourceCollapsed}
         streamingFile={streamingFile}
-        genericResourceData={genericResourceData}
+        genericResourceData={genericResourceData ?? undefined}
         className={skipResourceTransition ? '!transition-none' : undefined}
       />
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
index ac5bf1ab167..c755f4407ee 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
@@ -2,56 +2,65 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import { useQueryClient } from '@tanstack/react-query'
 import { usePathname } from 'next/navigation'
+import { toDisplayMessage } from '@/lib/copilot/chat/display-message'
+import type {
+  PersistedFileAttachment,
+  PersistedMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import { COPILOT_CHAT_API_PATH, MOTHERSHIP_CHAT_API_PATH } from '@/lib/copilot/constants'
+import type { MothershipStreamV1EventEnvelope } from '@/lib/copilot/generated/mothership-stream-v1'
 import {
-  cancelRunToolExecution,
-  executeRunToolOnClient,
-  markRunToolManuallyStopped,
-  reportManualRunToolStop,
-} from '@/lib/copilot/client-sse/run-tool-execution'
+  MothershipStreamV1EventType,
+  MothershipStreamV1ResourceOp,
+  MothershipStreamV1RunKind,
+  MothershipStreamV1SessionKind,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1SpanPayloadKind,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
 import {
-  COPILOT_CHAT_API_PATH,
-  COPILOT_CHAT_STREAM_API_PATH,
-  MOTHERSHIP_CHAT_API_PATH,
-} from '@/lib/copilot/constants'
+  CreateFolder,
+  DeleteFolder,
+  DeleteWorkflow,
+  DeployApi,
+  DeployChat,
+  DeployMcp,
+  File as FileTool,
+  MoveFolder,
+  MoveWorkflow,
+  Read as ReadTool,
+  Redeploy,
+  RenameWorkflow,
+  ToolSearchToolRegex,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   extractResourcesFromToolResult,
-  isEphemeralResource,
   isResourceToolName,
-} from '@/lib/copilot/resource-extraction'
-import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resource-types'
-import { isWorkflowToolName } from '@/lib/copilot/workflow-tools'
+} from '@/lib/copilot/resources/extraction'
+import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
+import {
+  cancelRunToolExecution,
+  executeRunToolOnClient,
+  isRunToolActiveForId,
+  markRunToolManuallyStopped,
+  reportManualRunToolStop,
+} from '@/lib/copilot/tools/client/run-tool-execution'
+import { isWorkflowToolName } from '@/lib/copilot/tools/workflow-tools'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getNextWorkflowColor } from '@/lib/workflows/colors'
 import { getQueryClient } from '@/app/_shell/providers/get-query-client'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
-import type {
-  ChatMessage,
-  ChatMessageAttachment,
-  ContentBlock,
-  ContentBlockType,
-  FileAttachmentForApi,
-  GenericResourceData,
-  GenericResourceEntry,
-  MothershipResource,
-  MothershipResourceType,
-  QueuedMessage,
-  SSEPayload,
-  SSEPayloadData,
-  ToolCallStatus,
-} from '@/app/workspace/[workspaceId]/home/types'
 import { deploymentKeys } from '@/hooks/queries/deployments'
 import {
   fetchChatHistory,
-  type StreamSnapshot,
   type TaskChatHistory,
-  type TaskStoredContentBlock,
-  type TaskStoredFileAttachment,
-  type TaskStoredMessage,
-  type TaskStoredToolCall,
   taskKeys,
   useChatHistory,
 } from '@/hooks/queries/tasks'
 import { getFolderMap } from '@/hooks/queries/utils/folder-cache'
+import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { invalidateWorkflowSelectors } from '@/hooks/queries/utils/invalidate-workflow-lists'
 import { getTopInsertionSortOrder } from '@/hooks/queries/utils/top-insertion-sort-order'
 import { getWorkflowById, getWorkflows } from '@/hooks/queries/utils/workflow-cache'
@@ -59,9 +68,18 @@ import { workflowKeys } from '@/hooks/queries/workflows'
 import { useExecutionStream } from '@/hooks/use-execution-stream'
 import { useExecutionStore } from '@/stores/execution/store'
 import type { ChatContext } from '@/stores/panel'
-import { consolePersistence, useTerminalConsoleStore } from '@/stores/terminal'
+import { useTerminalConsoleStore } from '@/stores/terminal'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import type { WorkflowMetadata } from '@/stores/workflows/registry/types'
+import type {
+  ChatMessage,
+  ContentBlock,
+  FileAttachmentForApi,
+  GenericResourceData,
+  MothershipResource,
+  MothershipResourceType,
+  QueuedMessage,
+} from '../types'
 
 export interface UseChatReturn {
   messages: ChatMessage[]
@@ -85,226 +103,107 @@ export interface UseChatReturn {
   removeFromQueue: (id: string) => void
   sendNow: (id: string) => Promise<void>
   editQueuedMessage: (id: string) => QueuedMessage | undefined
-  streamingFile: { fileName: string; content: string } | null
-  genericResourceData: GenericResourceData
+  streamingFile: StreamingFilePreview | null
+  genericResourceData: GenericResourceData | null
 }
 
-const STATE_TO_STATUS: Record<string, ToolCallStatus> = {
-  success: 'success',
-  error: 'error',
-  cancelled: 'cancelled',
-  rejected: 'error',
-  skipped: 'success',
-} as const
+const DEPLOY_TOOL_NAMES: Set<string> = new Set([
+  DeployApi.id,
+  DeployChat.id,
+  DeployMcp.id,
+  Redeploy.id,
+])
 
-const DEPLOY_TOOL_NAMES = new Set(['deploy_api', 'deploy_chat', 'deploy_mcp', 'redeploy'])
+const FOLDER_TOOL_NAMES: Set<string> = new Set([CreateFolder.id, DeleteFolder.id, MoveFolder.id])
+
+const WORKFLOW_MUTATION_TOOL_NAMES: Set<string> = new Set([
+  MoveWorkflow.id,
+  RenameWorkflow.id,
+  DeleteWorkflow.id,
+])
 const RECONNECT_TAIL_ERROR =
   'Live reconnect failed before the stream finished. The latest response may be incomplete.'
-const TERMINAL_STREAM_STATUSES = new Set(['complete', 'error', 'cancelled'])
 const MAX_RECONNECT_ATTEMPTS = 10
 const RECONNECT_BASE_DELAY_MS = 1000
 const RECONNECT_MAX_DELAY_MS = 30_000
 
-interface StreamEventEnvelope {
-  eventId: number
-  streamId: string
-  event: Record<string, unknown>
-}
-
-interface StreamBatchResponse {
-  success: boolean
-  events: StreamEventEnvelope[]
-  status: string
-}
-
-interface StreamTerminationResult {
-  sawStreamError: boolean
-  sawDoneEvent: boolean
-  lastEventId: number
-}
+const logger = createLogger('useChat')
 
-interface StreamProcessingOptions {
-  expectedGen?: number
-  initialLastEventId?: number
-  preserveExistingState?: boolean
-}
+type StreamPayload = Record<string, unknown>
 
-interface AttachToStreamOptions {
-  streamId: string
-  assistantId: string
-  expectedGen: number
-  snapshot?: StreamSnapshot | null
-  initialLastEventId?: number
+type StreamToolUI = {
+  hidden?: boolean
+  title?: string
+  phaseLabel?: string
+  clientExecutable?: boolean
 }
 
-interface AttachToStreamResult {
-  aborted: boolean
-  error: boolean
+type StreamingFilePreview = {
+  toolCallId: string
+  fileName: string
+  fileId?: string
+  targetKind?: 'new_file' | 'file_id'
+  operation?: string
+  edit?: Record<string, unknown>
+  content: string
 }
 
-interface PendingStreamRecovery {
+type StreamBatchEvent = {
+  eventId: number
   streamId: string
-  snapshot?: StreamSnapshot | null
+  event: Record<string, unknown>
 }
 
-function isTerminalStreamStatus(status?: string | null): boolean {
-  return Boolean(status && TERMINAL_STREAM_STATUSES.has(status))
+type StreamBatchResponse = {
+  success: boolean
+  events: StreamBatchEvent[]
+  status: string
 }
 
-function isActiveStreamConflictError(input: unknown): boolean {
-  if (typeof input !== 'string') return false
-  return input.includes('A response is already in progress for this chat')
-}
+const TERMINAL_STREAM_STATUSES = new Set(['complete', 'error', 'cancelled'])
 
-/**
- * Extracts tool call IDs from snapshot events so that replayed client-executable
- * tool calls are not re-executed after a page refresh.
- */
-function extractToolCallIdsFromSnapshot(snapshot?: StreamSnapshot | null): Set<string> {
-  const ids = new Set<string>()
-  if (!snapshot?.events) return ids
-  for (const entry of snapshot.events) {
-    const event = entry.event
-    if (event.type === 'tool_call' && typeof event.toolCallId === 'string') {
-      ids.add(event.toolCallId)
-    }
-  }
-  return ids
+function isTerminalStreamStatus(status: string | null | undefined): boolean {
+  return TERMINAL_STREAM_STATUSES.has(status ?? '')
 }
 
-function buildReplayStream(events: StreamEventEnvelope[]): ReadableStream<Uint8Array> {
-  const encoder = new TextEncoder()
-  return new ReadableStream<Uint8Array>({
+const sseEncoder = new TextEncoder()
+function buildReplayStream(events: StreamBatchEvent[]): ReadableStream<Uint8Array> {
+  return new ReadableStream({
     start(controller) {
-      if (events.length > 0) {
-        const payload = events
-          .map(
-            (entry) =>
-              `data: ${JSON.stringify({ ...entry.event, eventId: entry.eventId, streamId: entry.streamId })}\n\n`
-          )
-          .join('')
-        controller.enqueue(encoder.encode(payload))
-      }
+      const payload = events
+        .map(
+          (entry) =>
+            `data: ${JSON.stringify({ ...entry.event, eventId: entry.eventId, streamId: entry.streamId })}\n\n`
+        )
+        .join('')
+      controller.enqueue(sseEncoder.encode(payload))
       controller.close()
     },
   })
 }
 
-function mapStoredBlock(block: TaskStoredContentBlock): ContentBlock {
-  if (block.type === 'thinking') {
-    return {
-      type: 'text',
-      content: block.content ? `<thinking>${block.content}</thinking>` : '',
-    }
-  }
-
-  const mapped: ContentBlock = {
-    type: block.type as ContentBlockType,
-    content: block.content,
-  }
-
-  if (block.type === 'tool_call' && block.toolCall) {
-    const resolvedStatus = STATE_TO_STATUS[block.toolCall.state ?? ''] ?? 'error'
-    mapped.toolCall = {
-      id: block.toolCall.id ?? '',
-      name: block.toolCall.name ?? 'unknown',
-      status: resolvedStatus,
-      displayTitle:
-        resolvedStatus === 'cancelled' ? 'Stopped by user' : block.toolCall.display?.text,
-      params: block.toolCall.params,
-      calledBy: block.toolCall.calledBy,
-      result: block.toolCall.result,
-    }
-  }
-
-  return mapped
-}
-
-function mapStoredToolCall(tc: TaskStoredToolCall): ContentBlock {
-  const resolvedStatus = (STATE_TO_STATUS[tc.status] ?? 'error') as ToolCallStatus
-  return {
-    type: 'tool_call',
-    toolCall: {
-      id: tc.id,
-      name: tc.name,
-      status: resolvedStatus,
-      displayTitle: resolvedStatus === 'cancelled' ? 'Stopped by user' : undefined,
-      params: tc.params,
-      result:
-        tc.result != null
-          ? {
-              success: tc.status === 'success',
-              output: tc.result,
-              error: tc.error,
-            }
-          : undefined,
-    },
-  }
+function asPayloadRecord(value: unknown): StreamPayload | undefined {
+  return value && typeof value === 'object' ? (value as StreamPayload) : undefined
 }
 
-function toDisplayAttachment(f: TaskStoredFileAttachment): ChatMessageAttachment {
-  return {
-    id: f.id,
-    filename: f.filename,
-    media_type: f.media_type,
-    size: f.size,
-    previewUrl: f.media_type.startsWith('image/')
-      ? `/api/files/serve/${encodeURIComponent(f.key)}?context=mothership`
-      : undefined,
-  }
+function getPayloadData(event: MothershipStreamV1EventEnvelope): StreamPayload {
+  return asPayloadRecord(event.payload) ?? {}
 }
 
-function mapStoredMessage(msg: TaskStoredMessage): ChatMessage {
-  const mapped: ChatMessage = {
-    id: msg.id,
-    role: msg.role,
-    content: msg.content,
-    ...(msg.requestId ? { requestId: msg.requestId } : {}),
-  }
-
-  const hasContentBlocks = Array.isArray(msg.contentBlocks) && msg.contentBlocks.length > 0
-  const hasToolCalls = Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0
-  const contentBlocksHaveTools =
-    hasContentBlocks && msg.contentBlocks!.some((b) => b.type === 'tool_call')
-
-  if (hasContentBlocks && (!hasToolCalls || contentBlocksHaveTools)) {
-    const blocks = msg.contentBlocks!.map(mapStoredBlock)
-    const hasText = blocks.some((b) => b.type === 'text' && b.content?.trim())
-    if (!hasText && msg.content?.trim()) {
-      blocks.push({ type: 'text', content: msg.content })
-    }
-    mapped.contentBlocks = blocks
-  } else if (hasToolCalls) {
-    const blocks: ContentBlock[] = msg.toolCalls!.map(mapStoredToolCall)
-    if (msg.content?.trim()) {
-      blocks.push({ type: 'text', content: msg.content })
-    }
-    mapped.contentBlocks = blocks
-  }
-
-  if (Array.isArray(msg.fileAttachments) && msg.fileAttachments.length > 0) {
-    mapped.attachments = msg.fileAttachments.map(toDisplayAttachment)
+function getToolUI(payload: StreamPayload): StreamToolUI | undefined {
+  const raw = asPayloadRecord(payload.ui)
+  if (!raw) {
+    return undefined
   }
 
-  if (Array.isArray(msg.contexts) && msg.contexts.length > 0) {
-    mapped.contexts = msg.contexts.map((c) => ({
-      kind: c.kind,
-      label: c.label,
-      ...(c.workflowId && { workflowId: c.workflowId }),
-      ...(c.knowledgeId && { knowledgeId: c.knowledgeId }),
-      ...(c.tableId && { tableId: c.tableId }),
-      ...(c.fileId && { fileId: c.fileId }),
-      ...(c.folderId && { folderId: c.folderId }),
-    }))
+  return {
+    ...(typeof raw.hidden === 'boolean' ? { hidden: raw.hidden } : {}),
+    ...(typeof raw.title === 'string' ? { title: raw.title } : {}),
+    ...(typeof raw.phaseLabel === 'string' ? { phaseLabel: raw.phaseLabel } : {}),
+    ...(typeof raw.clientExecutable === 'boolean'
+      ? { clientExecutable: raw.clientExecutable }
+      : {}),
   }
-
-  return mapped
-}
-
-const logger = createLogger('useChat')
-
-function getPayloadData(payload: SSEPayload): SSEPayloadData | undefined {
-  return typeof payload.data === 'object' ? payload.data : undefined
 }
 
 /** Adds a workflow to the React Query cache with a top-insertion sort order if it doesn't already exist. */
@@ -420,6 +319,7 @@ export function useChat(
   const [resources, setResources] = useState<MothershipResource[]>([])
   const [activeResourceId, setActiveResourceId] = useState<string | null>(null)
   const initialActiveResourceIdRef = useRef(options?.initialActiveResourceId)
+  const [genericResourceData, setGenericResourceData] = useState<GenericResourceData | null>(null)
   const onResourceEventRef = useRef(options?.onResourceEvent)
   onResourceEventRef.current = options?.onResourceEvent
   const apiPathRef = useRef(options?.apiPath ?? MOTHERSHIP_CHAT_API_PATH)
@@ -449,46 +349,29 @@ export function useChat(
   const activeResourceIdRef = useRef(effectiveActiveResourceId)
   activeResourceIdRef.current = effectiveActiveResourceId
 
-  const [streamingFile, setStreamingFile] = useState<{
-    fileName: string
-    content: string
-  } | null>(null)
+  const [streamingFile, setStreamingFile] = useState<StreamingFilePreview | null>(null)
   const streamingFileRef = useRef(streamingFile)
   streamingFileRef.current = streamingFile
-
-  const [genericResourceData, setGenericResourceData] = useState<GenericResourceData>({
-    entries: [],
-  })
-  const genericResourceDataRef = useRef<GenericResourceData>({ entries: [] })
+  const filePreviewSessionsRef = useRef<Map<string, StreamingFilePreview>>(new Map())
+  const activeFilePreviewToolCallIdRef = useRef<string | null>(null)
 
   const [messageQueue, setMessageQueue] = useState<QueuedMessage[]>([])
   const messageQueueRef = useRef<QueuedMessage[]>([])
   messageQueueRef.current = messageQueue
-  const [pendingRecoveryMessage, setPendingRecoveryMessage] = useState<QueuedMessage | null>(null)
-  const pendingRecoveryMessageRef = useRef<QueuedMessage | null>(null)
-  pendingRecoveryMessageRef.current = pendingRecoveryMessage
 
   const sendMessageRef = useRef<UseChatReturn['sendMessage']>(async () => {})
   const processSSEStreamRef = useRef<
     (
       reader: ReadableStreamDefaultReader<Uint8Array>,
       assistantId: string,
-      options?: StreamProcessingOptions
-    ) => Promise<StreamTerminationResult>
-  >(async () => ({
-    sawStreamError: false,
-    sawDoneEvent: false,
-    lastEventId: 0,
-  }))
-  const finalizeRef = useRef<(options?: { error?: boolean }) => void>(() => {})
+      expectedGen?: number,
+      options?: { preserveExistingState?: boolean }
+    ) => Promise<{ sawStreamError: boolean; sawComplete: boolean }>
+  >(async () => ({ sawStreamError: false, sawComplete: false }))
   const retryReconnectRef = useRef<
-    (opts: {
-      streamId: string
-      assistantId: string
-      gen: number
-      initialSnapshot?: StreamSnapshot | null
-    }) => Promise<boolean>
+    (opts: { streamId: string; assistantId: string; gen: number }) => Promise<boolean>
   >(async () => false)
+  const finalizeRef = useRef<(options?: { error?: boolean }) => void>(() => {})
 
   const abortControllerRef = useRef<AbortController | null>(null)
   const streamReaderRef = useRef<ReadableStreamDefaultReader<Uint8Array> | null>(null)
@@ -499,7 +382,7 @@ export function useChat(
   const appliedChatIdRef = useRef<string | undefined>(undefined)
   const pendingUserMsgRef = useRef<{ id: string; content: string } | null>(null)
   const streamIdRef = useRef<string | undefined>(undefined)
-  const lastEventIdRef = useRef(0)
+  const lastCursorRef = useRef('0')
   const sendingRef = useRef(false)
   const streamGenRef = useRef(0)
   const streamingContentRef = useRef('')
@@ -522,7 +405,7 @@ export function useChat(
     })
     setActiveResourceId(resource.id)
 
-    if (isEphemeralResource(resource)) {
+    if (resource.id === 'streaming-file') {
       return true
     }
 
@@ -547,6 +430,56 @@ export function useChat(
     setResources(newOrder)
   }, [])
 
+  const startClientWorkflowTool = useCallback(
+    (toolCallId: string, toolName: string, toolArgs: Record<string, unknown>) => {
+      if (!isWorkflowToolName(toolName)) {
+        return
+      }
+      if (clientExecutionStartedRef.current.has(toolCallId) && isRunToolActiveForId(toolCallId)) {
+        return
+      }
+      clientExecutionStartedRef.current.add(toolCallId)
+
+      const targetWorkflowId =
+        typeof toolArgs.workflowId === 'string'
+          ? toolArgs.workflowId
+          : useWorkflowRegistry.getState().activeWorkflowId
+      if (targetWorkflowId) {
+        const meta = getWorkflowById(workspaceId, targetWorkflowId)
+        const wasAdded = addResource({
+          type: 'workflow',
+          id: targetWorkflowId,
+          title: meta?.name ?? 'Workflow',
+        })
+        if (!wasAdded && activeResourceIdRef.current !== targetWorkflowId) {
+          setActiveResourceId(targetWorkflowId)
+        }
+        onResourceEventRef.current?.()
+      }
+
+      executeRunToolOnClient(toolCallId, toolName, toolArgs)
+    },
+    [addResource, workspaceId]
+  )
+
+  const recoverPendingClientWorkflowTools = useCallback(
+    (nextMessages: ChatMessage[]) => {
+      for (const message of nextMessages) {
+        for (const block of message.contentBlocks ?? []) {
+          const toolCall = block.toolCall
+          if (!toolCall || !isWorkflowToolName(toolCall.name)) {
+            continue
+          }
+          if (toolCall.status !== 'executing') {
+            continue
+          }
+          startClientWorkflowTool(toolCall.id, toolCall.name, toolCall.params ?? {})
+        }
+      }
+    },
+    [startClientWorkflowTool]
+  )
+
   useEffect(() => {
     if (sendingRef.current) {
       const streamOwnerId = chatIdRef.current
@@ -562,10 +495,6 @@ export function useChat(
         abortControllerRef.current = null
         sendingRef.current = false
         setIsSending(false)
-        setIsReconnecting(false)
-        lastEventIdRef.current = 0
-        pendingRecoveryMessageRef.current = null
-        setPendingRecoveryMessage(null)
         if (abandonedChatId) {
           queryClient.invalidateQueries({ queryKey: taskKeys.detail(abandonedChatId) })
         }
@@ -576,6 +505,7 @@ export function useChat(
       }
     }
     chatIdRef.current = initialChatId
+    lastCursorRef.current = '0'
     setResolvedChatId(initialChatId)
     appliedChatIdRef.current = undefined
     setMessages([])
@@ -586,13 +516,9 @@ export function useChat(
     setActiveResourceId(null)
     setStreamingFile(null)
     streamingFileRef.current = null
-    genericResourceDataRef.current = { entries: [] }
-    setGenericResourceData({ entries: [] })
+    filePreviewSessionsRef.current.clear()
+    activeFilePreviewToolCallIdRef.current = null
     setMessageQueue([])
-    lastEventIdRef.current = 0
-    clientExecutionStartedRef.current.clear()
-    pendingRecoveryMessageRef.current = null
-    setPendingRecoveryMessage(null)
   }, [initialChatId, queryClient])
 
   useEffect(() => {
@@ -600,6 +526,7 @@ export function useChat(
     if (!isHomePage || !chatIdRef.current) return
     streamGenRef.current++
     chatIdRef.current = undefined
+    lastCursorRef.current = '0'
     setResolvedChatId(undefined)
     appliedChatIdRef.current = undefined
     abortControllerRef.current = null
@@ -612,291 +539,64 @@ export function useChat(
     setActiveResourceId(null)
     setStreamingFile(null)
     streamingFileRef.current = null
-    genericResourceDataRef.current = { entries: [] }
-    setGenericResourceData({ entries: [] })
+    filePreviewSessionsRef.current.clear()
+    activeFilePreviewToolCallIdRef.current = null
     setMessageQueue([])
-    lastEventIdRef.current = 0
-    clientExecutionStartedRef.current.clear()
-    pendingRecoveryMessageRef.current = null
-    setPendingRecoveryMessage(null)
   }, [isHomePage])
 
-  const fetchStreamBatch = useCallback(
-    async (
-      streamId: string,
-      fromEventId: number,
-      signal?: AbortSignal
-    ): Promise<StreamBatchResponse> => {
-      const response = await fetch(
-        `${COPILOT_CHAT_STREAM_API_PATH}?streamId=${encodeURIComponent(streamId)}&from=${fromEventId}&batch=true`,
-        { signal }
-      )
-
-      if (!response.ok) {
-        throw new Error(`Stream resume batch failed: ${response.status}`)
-      }
-
-      return response.json()
-    },
-    []
-  )
-
-  const attachToExistingStream = useCallback(
-    async ({
-      streamId,
-      assistantId,
-      expectedGen,
-      snapshot,
-      initialLastEventId = 0,
-    }: AttachToStreamOptions): Promise<AttachToStreamResult> => {
-      let latestEventId = initialLastEventId
-      let seedEvents = snapshot?.events ?? []
-      let streamStatus = snapshot?.status ?? 'unknown'
-      let attachAttempt = 0
-
-      setIsSending(true)
-      setIsReconnecting(true)
-      setError(null)
-
-      logger.info('Attaching to existing stream', {
-        streamId,
-        expectedGen,
-        initialLastEventId,
-        seedEventCount: seedEvents.length,
-        streamStatus,
-      })
-
-      try {
-        while (streamGenRef.current === expectedGen) {
-          if (seedEvents.length > 0) {
-            const replayResult = await processSSEStreamRef.current(
-              buildReplayStream(seedEvents).getReader(),
-              assistantId,
-              {
-                expectedGen,
-                initialLastEventId: latestEventId,
-                preserveExistingState: true,
-              }
-            )
-            latestEventId = Math.max(
-              replayResult.lastEventId,
-              seedEvents[seedEvents.length - 1]?.eventId ?? latestEventId
-            )
-            lastEventIdRef.current = latestEventId
-            seedEvents = []
-
-            if (replayResult.sawStreamError) {
-              logger.warn('Replay stream ended with error event', { streamId, latestEventId })
-              return { aborted: false, error: true }
-            }
-          }
-
-          if (isTerminalStreamStatus(streamStatus)) {
-            logger.info('Existing stream already reached terminal status', {
-              streamId,
-              latestEventId,
-              streamStatus,
-            })
-            if (streamStatus === 'error') {
-              setError(RECONNECT_TAIL_ERROR)
-            }
-            return { aborted: false, error: streamStatus === 'error' }
-          }
-
-          const activeAbortController = abortControllerRef.current
-          if (!activeAbortController) {
-            return { aborted: true, error: false }
-          }
-
-          logger.info('Opening live stream tail', {
-            streamId,
-            fromEventId: latestEventId,
-            attempt: attachAttempt,
-          })
-
-          const sseRes = await fetch(
-            `${COPILOT_CHAT_STREAM_API_PATH}?streamId=${encodeURIComponent(streamId)}&from=${latestEventId}`,
-            { signal: activeAbortController.signal }
-          )
-          if (!sseRes.ok || !sseRes.body) {
-            throw new Error(RECONNECT_TAIL_ERROR)
-          }
-
-          setIsReconnecting(false)
-
-          const liveResult = await processSSEStreamRef.current(
-            sseRes.body.getReader(),
-            assistantId,
-            {
-              expectedGen,
-              initialLastEventId: latestEventId,
-              preserveExistingState: true,
-            }
-          )
-          latestEventId = Math.max(latestEventId, liveResult.lastEventId)
-          lastEventIdRef.current = latestEventId
-
-          if (liveResult.sawStreamError) {
-            logger.warn('Live stream tail ended with error event', { streamId, latestEventId })
-            return { aborted: false, error: true }
-          }
-
-          attachAttempt += 1
-          setIsReconnecting(true)
-
-          logger.warn('Live stream ended without terminal event, fetching replay batch', {
-            streamId,
-            latestEventId,
-            attempt: attachAttempt,
-          })
-
-          const batch = await fetchStreamBatch(
-            streamId,
-            latestEventId,
-            activeAbortController.signal
-          )
-          seedEvents = batch.events
-          streamStatus = batch.status
-
-          if (batch.events.length > 0) {
-            latestEventId = batch.events[batch.events.length - 1].eventId
-            lastEventIdRef.current = latestEventId
-          }
-
-          logger.info('Fetched replay batch after non-terminal stream close', {
-            streamId,
-            latestEventId,
-            streamStatus,
-            eventCount: batch.events.length,
-            attempt: attachAttempt,
-          })
-
-          if (batch.events.length === 0 && !isTerminalStreamStatus(batch.status)) {
-            logger.info('No new replay events yet; reopening active stream tail', {
-              streamId,
-              latestEventId,
-              streamStatus,
-              attempt: attachAttempt,
-            })
-            if (activeAbortController.signal.aborted || streamGenRef.current !== expectedGen) {
-              return { aborted: true, error: false }
-            }
-          }
-        }
+  useEffect(() => {
+    if (!chatHistory || appliedChatIdRef.current === chatHistory.id) return
 
-        return { aborted: true, error: false }
-      } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') {
-          return { aborted: true, error: false }
+    const activeStreamId = chatHistory.activeStreamId
+    appliedChatIdRef.current = chatHistory.id
+    const mappedMessages = chatHistory.messages.map(toDisplayMessage)
+    const shouldPreserveActiveStreamingMessage =
+      sendingRef.current && Boolean(activeStreamId) && activeStreamId === streamIdRef.current
+
+    if (shouldPreserveActiveStreamingMessage) {
+      setMessages((prev) => {
+        const localStreamingAssistant = prev[prev.length - 1]
+        if (localStreamingAssistant?.role !== 'assistant') {
+          return mappedMessages
         }
 
-        logger.error('Failed to attach to existing stream, will throw for outer retry', {
-          streamId,
-          latestEventId,
-          error: err instanceof Error ? err.message : String(err),
-        })
-        throw err
-      } finally {
-        setIsReconnecting(false)
-      }
-    },
-    [fetchStreamBatch]
-  )
-
-  const applyChatHistorySnapshot = useCallback(
-    (history: TaskChatHistory, options?: { preserveActiveStreamingMessage?: boolean }) => {
-      const preserveActiveStreamingMessage = options?.preserveActiveStreamingMessage ?? false
-      const activeStreamId = history.activeStreamId
-      appliedChatIdRef.current = history.id
-
-      const mappedMessages = history.messages.map(mapStoredMessage)
-      const shouldPreserveActiveStreamingMessage =
-        preserveActiveStreamingMessage &&
-        sendingRef.current &&
-        Boolean(activeStreamId) &&
-        activeStreamId === streamIdRef.current
-
-      if (shouldPreserveActiveStreamingMessage) {
-        setMessages((prev) => {
-          const localStreamingAssistant = prev[prev.length - 1]
-          if (localStreamingAssistant?.role !== 'assistant') {
-            return mappedMessages
-          }
-
-          const nextMessages =
-            mappedMessages[mappedMessages.length - 1]?.role === 'assistant'
-              ? mappedMessages.slice(0, -1)
-              : mappedMessages
-
-          return [...nextMessages, localStreamingAssistant]
-        })
-      } else {
-        setMessages(mappedMessages)
-      }
+        const nextMessages =
+          mappedMessages[mappedMessages.length - 1]?.role === 'assistant'
+            ? mappedMessages.slice(0, -1)
+            : mappedMessages
 
-      if (history.resources.some((r) => r.id === 'streaming-file')) {
-        fetch('/api/copilot/chat/resources', {
-          method: 'DELETE',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            chatId: history.id,
-            resourceType: 'file',
-            resourceId: 'streaming-file',
-          }),
-        }).catch(() => {})
-      }
+        return [...nextMessages, localStreamingAssistant]
+      })
+    } else {
+      setMessages(mappedMessages)
+    }
 
-      const persistedResources = history.resources.filter((r) => r.id !== 'streaming-file')
-      if (persistedResources.length > 0) {
-        setResources(persistedResources)
-        const initialId = initialActiveResourceIdRef.current
-        const restoredId =
-          initialId && persistedResources.some((r) => r.id === initialId)
-            ? initialId
-            : persistedResources[persistedResources.length - 1].id
-        setActiveResourceId(restoredId)
-
-        for (const resource of persistedResources) {
-          if (resource.type !== 'workflow') continue
-          ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
-        }
-      } else if (history.resources.some((r) => r.id === 'streaming-file')) {
-        setResources([])
-        setActiveResourceId(null)
-      }
-    },
-    [workspaceId]
-  )
+    recoverPendingClientWorkflowTools(mappedMessages)
 
-  const preparePendingStreamRecovery = useCallback(
-    async (chatId: string): Promise<PendingStreamRecovery | null> => {
-      const latestHistory = await fetchChatHistory(chatId)
-      queryClient.setQueryData(taskKeys.detail(chatId), latestHistory)
-      applyChatHistorySnapshot(latestHistory)
+    if (chatHistory.resources.some((r) => r.id === 'streaming-file')) {
+      fetch('/api/copilot/chat/resources', {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chatId: chatHistory.id,
+          resourceType: 'file',
+          resourceId: 'streaming-file',
+        }),
+      }).catch(() => {})
+    }
 
-      if (!latestHistory.activeStreamId) {
-        return null
-      }
+    const persistedResources = chatHistory.resources.filter((r) => r.id !== 'streaming-file')
+    if (persistedResources.length > 0) {
+      setResources(persistedResources)
+      setActiveResourceId(persistedResources[persistedResources.length - 1].id)
 
-      return {
-        streamId: latestHistory.activeStreamId,
-        snapshot: latestHistory.streamSnapshot,
+      for (const resource of persistedResources) {
+        if (resource.type !== 'workflow') continue
+        ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
       }
-    },
-    [applyChatHistorySnapshot, queryClient]
-  )
-
-  useEffect(() => {
-    if (!chatHistory) return
-
-    const activeStreamId = chatHistory.activeStreamId
-    const snapshot = chatHistory.streamSnapshot
-    const isNewChat = appliedChatIdRef.current !== chatHistory.id
-
-    if (isNewChat) {
-      applyChatHistorySnapshot(chatHistory, { preserveActiveStreamingMessage: true })
-    } else if (!activeStreamId || sendingRef.current) {
-      return
+    } else if (chatHistory.resources.some((r) => r.id === 'streaming-file')) {
+      setResources([])
+      setActiveResourceId(null)
     }
 
     if (activeStreamId && !sendingRef.current) {
@@ -904,11 +604,8 @@ export function useChat(
       const abortController = new AbortController()
       abortControllerRef.current = abortController
       streamIdRef.current = activeStreamId
-      lastEventIdRef.current = snapshot?.events?.[snapshot.events.length - 1]?.eventId ?? 0
+      lastCursorRef.current = '0'
       sendingRef.current = true
-      streamingContentRef.current = ''
-      streamingBlocksRef.current = []
-      clientExecutionStartedRef.current = extractToolCallIdsFromSnapshot(snapshot)
 
       const assistantId = generateId()
 
@@ -917,7 +614,6 @@ export function useChat(
           streamId: activeStreamId,
           assistantId,
           gen,
-          initialSnapshot: snapshot,
         })
         if (!succeeded && streamGenRef.current === gen) {
           try {
@@ -933,51 +629,59 @@ export function useChat(
       }
       reconnect()
     }
-  }, [applyChatHistorySnapshot, chatHistory, queryClient])
+  }, [chatHistory, workspaceId, queryClient, recoverPendingClientWorkflowTools])
 
   const processSSEStream = useCallback(
     async (
       reader: ReadableStreamDefaultReader<Uint8Array>,
       assistantId: string,
-      options?: StreamProcessingOptions
+      expectedGen?: number,
+      options?: { preserveExistingState?: boolean }
     ) => {
-      const { expectedGen, initialLastEventId = 0, preserveExistingState = false } = options ?? {}
       const decoder = new TextDecoder()
       streamReaderRef.current = reader
       let buffer = ''
-      const blocks: ContentBlock[] = preserveExistingState ? [...streamingBlocksRef.current] : []
+
+      const preserveState = options?.preserveExistingState === true
+      const blocks: ContentBlock[] = preserveState ? [...streamingBlocksRef.current] : []
       const toolMap = new Map<string, number>()
       const toolArgsMap = new Map<string, Record<string, unknown>>()
-      // Maps toolCallId → index in genericResourceDataRef.current.entries for fast lookup
-      const genericEntryMap = new Map<string, number>()
-      if (preserveExistingState) {
-        for (const [idx, entry] of genericResourceDataRef.current.entries.entries()) {
-          genericEntryMap.set(entry.toolCallId, idx)
+
+      if (preserveState) {
+        for (let i = 0; i < blocks.length; i++) {
+          const tc = blocks[i].toolCall
+          if (tc) {
+            toolMap.set(tc.id, i)
+            if (tc.params) toolArgsMap.set(tc.id, tc.params)
+          }
         }
       }
-      const clientExecutionStarted = clientExecutionStartedRef.current
+
       let activeSubagent: string | undefined
+      let activeSubagentParentToolCallId: string | undefined
       let activeCompactionId: string | undefined
-      let runningText = preserveExistingState ? streamingContentRef.current : ''
-      let lastContentSource: 'main' | 'subagent' | null = null
-      let streamRequestId: string | undefined
-      let lastEventId = initialLastEventId
-      let sawDoneEvent = false
 
-      if (!preserveExistingState) {
-        streamingContentRef.current = ''
-        streamingBlocksRef.current = []
-      }
-
-      for (const [index, block] of blocks.entries()) {
-        if (block.type === 'tool_call' && block.toolCall?.id) {
-          toolMap.set(block.toolCall.id, index)
-          if (block.toolCall.params) {
-            toolArgsMap.set(block.toolCall.id, block.toolCall.params)
+      if (preserveState) {
+        for (let i = blocks.length - 1; i >= 0; i--) {
+          if (blocks[i].type === 'subagent' && blocks[i].content) {
+            activeSubagent = blocks[i].content
+            break
+          }
+          if (blocks[i].type === 'subagent_end') {
+            break
           }
         }
       }
 
+      let runningText = preserveState ? streamingContentRef.current || '' : ''
+      let lastContentSource: 'main' | 'subagent' | null = null
+      let streamRequestId: string | undefined
+
+      if (!preserveState) {
+        streamingContentRef.current = ''
+        streamingBlocksRef.current = []
+      }
+
       const ensureTextBlock = (): ContentBlock => {
         const last = blocks[blocks.length - 1]
         if (last?.type === 'text' && last.subagent === activeSubagent) return last
@@ -997,14 +701,15 @@ export function useChat(
         flush()
       }
 
-      const buildInlineErrorTag = (payload: SSEPayload) => {
-        const data = getPayloadData(payload) as Record<string, unknown> | undefined
+      const buildInlineErrorTag = (event: MothershipStreamV1EventEnvelope) => {
+        const data = getPayloadData(event)
         const message =
-          (data?.displayMessage as string | undefined) ||
-          payload.error ||
+          (typeof data.displayMessage === 'string' ? data.displayMessage : undefined) ||
+          (typeof data.message === 'string' ? data.message : undefined) ||
+          (typeof data.error === 'string' ? data.error : undefined) ||
           'An unexpected error occurred'
-        const provider = (data?.provider as string | undefined) || undefined
-        const code = (data?.code as string | undefined) || undefined
+        const provider = typeof data.provider === 'string' ? data.provider : undefined
+        const code = typeof data.code === 'string' ? data.code : undefined
         return `<mothership-error>${JSON.stringify({
           message,
           ...(code ? { code } : {}),
@@ -1014,6 +719,7 @@ export function useChat(
 
       const isStale = () => expectedGen !== undefined && streamGenRef.current !== expectedGen
       let sawStreamError = false
+      let sawCompleteEvent = false
 
       const flush = () => {
         if (isStale()) return
@@ -1036,292 +742,184 @@ export function useChat(
         })
       }
 
-      const appendGenericEntry = (entry: GenericResourceEntry): number => {
-        const entries = [...genericResourceDataRef.current.entries, entry]
-        genericResourceDataRef.current.entries = entries
-        setGenericResourceData({ entries })
-        return entries.length - 1
-      }
-
-      const updateGenericEntry = (
-        entryIdx: number,
-        changes: Partial<GenericResourceEntry>
-      ): void => {
-        const entries = genericResourceDataRef.current.entries.slice()
-        entries[entryIdx] = { ...entries[entryIdx], ...changes }
-        genericResourceDataRef.current.entries = entries
-        setGenericResourceData({ entries })
-      }
-
       try {
+        const pendingLines: string[] = []
+
         while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          if (isStale()) continue
-
-          buffer += decoder.decode(value, { stream: true })
-          const lines = buffer.split('\n')
-          buffer = lines.pop() || ''
-
-          for (const line of lines) {
-            if (isStale()) break
-            if (!line.startsWith('data: ')) continue
-            const raw = line.slice(6)
-
-            let parsed: SSEPayload
-            try {
-              parsed = JSON.parse(raw)
-            } catch {
-              continue
-            }
+          if (pendingLines.length === 0) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (isStale()) continue
+
+            buffer += decoder.decode(value, { stream: true })
+            const lines = buffer.split('\n')
+            buffer = lines.pop() || ''
+            pendingLines.push(...lines)
+          }
 
-            if (typeof (parsed as SSEPayload & { eventId?: unknown }).eventId === 'number') {
-              lastEventId = Math.max(
-                lastEventId,
-                (parsed as SSEPayload & { eventId: number }).eventId
-              )
-              lastEventIdRef.current = lastEventId
-            }
+          const line = pendingLines.shift()!
+          if (isStale()) {
+            pendingLines.length = 0
+            continue
+          }
+          if (!line.startsWith('data: ')) continue
+          const raw = line.slice(6)
 
-            logger.debug('SSE event received', parsed)
-            switch (parsed.type) {
-              case 'chat_id': {
-                if (parsed.chatId) {
-                  const isNewChat = !chatIdRef.current
-                  chatIdRef.current = parsed.chatId
-                  const selected = selectedChatIdRef.current
-                  if (selected == null) {
-                    if (isNewChat) {
-                      setResolvedChatId(parsed.chatId)
-                    }
-                  } else if (parsed.chatId === selected) {
-                    setResolvedChatId(parsed.chatId)
-                  }
-                  queryClient.invalidateQueries({
-                    queryKey: taskKeys.list(workspaceId),
-                  })
+          let parsed: MothershipStreamV1EventEnvelope
+          try {
+            parsed = JSON.parse(raw)
+          } catch {
+            continue
+          }
+
+          if (parsed.trace?.requestId && parsed.trace.requestId !== streamRequestId) {
+            streamRequestId = parsed.trace.requestId
+            flush()
+          }
+          if (parsed.stream?.streamId) {
+            streamIdRef.current = parsed.stream.streamId
+          }
+          if (parsed.stream?.cursor) {
+            lastCursorRef.current = parsed.stream.cursor
+          } else if (typeof parsed.seq === 'number') {
+            lastCursorRef.current = String(parsed.seq)
+          }
+
+          logger.debug('SSE event received', parsed)
+          switch (parsed.type) {
+            case MothershipStreamV1EventType.session: {
+              const payload = getPayloadData(parsed)
+              const kind = typeof payload.kind === 'string' ? payload.kind : ''
+              const payloadChatId =
+                typeof payload.chatId === 'string'
+                  ? payload.chatId
+                  : typeof parsed.stream?.chatId === 'string'
+                    ? parsed.stream.chatId
+                    : undefined
+              if (kind === MothershipStreamV1SessionKind.chat && payloadChatId) {
+                const isNewChat = !chatIdRef.current
+                chatIdRef.current = payloadChatId
+                const selected = selectedChatIdRef.current
+                if (selected == null) {
                   if (isNewChat) {
-                    const userMsg = pendingUserMsgRef.current
-                    const activeStreamId = streamIdRef.current
-                    if (userMsg && activeStreamId) {
-                      queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(parsed.chatId), {
-                        id: parsed.chatId,
-                        title: null,
-                        messages: [
-                          {
-                            id: userMsg.id,
-                            role: 'user',
-                            content: userMsg.content,
-                          },
-                        ],
-                        activeStreamId,
-                        resources: [],
-                      })
-                    }
-                    if (!workflowIdRef.current) {
-                      window.history.replaceState(
-                        null,
-                        '',
-                        `/workspace/${workspaceId}/task/${parsed.chatId}`
-                      )
-                    }
+                    setResolvedChatId(payloadChatId)
                   }
+                } else if (payloadChatId === selected) {
+                  setResolvedChatId(payloadChatId)
                 }
-                break
-              }
-              case 'request_id': {
-                const rid = typeof parsed.data === 'string' ? parsed.data : undefined
-                if (rid) {
-                  streamRequestId = rid
-                  flush()
+                queryClient.invalidateQueries({
+                  queryKey: taskKeys.list(workspaceId),
+                })
+                if (isNewChat) {
+                  const userMsg = pendingUserMsgRef.current
+                  const activeStreamId = streamIdRef.current
+                  if (userMsg && activeStreamId) {
+                    queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(payloadChatId), {
+                      id: payloadChatId,
+                      title: null,
+                      messages: [
+                        {
+                          id: userMsg.id,
+                          role: 'user',
+                          content: userMsg.content,
+                          timestamp: new Date().toISOString(),
+                        },
+                      ],
+                      activeStreamId,
+                      resources: [],
+                    })
+                  }
+                  if (!workflowIdRef.current) {
+                    window.history.replaceState(
+                      null,
+                      '',
+                      `/workspace/${workspaceId}/task/${payloadChatId}`
+                    )
+                  }
                 }
-                break
               }
-              case 'content': {
-                const chunk = typeof parsed.data === 'string' ? parsed.data : (parsed.content ?? '')
-                if (chunk) {
-                  const contentSource: 'main' | 'subagent' = activeSubagent ? 'subagent' : 'main'
-                  const needsBoundaryNewline =
-                    lastContentSource !== null &&
-                    lastContentSource !== contentSource &&
-                    runningText.length > 0 &&
-                    !runningText.endsWith('\n')
-                  const tb = ensureTextBlock()
-                  const normalizedChunk = needsBoundaryNewline ? `\n${chunk}` : chunk
-                  tb.content = (tb.content ?? '') + normalizedChunk
-                  if (activeSubagent) tb.subagent = activeSubagent
-                  runningText += normalizedChunk
-                  lastContentSource = contentSource
-                  streamingContentRef.current = runningText
-                  flush()
-                }
-                break
+              if (kind === MothershipStreamV1SessionKind.title) {
+                queryClient.invalidateQueries({
+                  queryKey: taskKeys.list(workspaceId),
+                })
+                onTitleUpdateRef.current?.()
               }
-              case 'reasoning': {
-                const d = (
-                  parsed.data && typeof parsed.data === 'object' ? parsed.data : {}
-                ) as Record<string, unknown>
-                const phase = d.phase as string | undefined
-                if (phase === 'start') {
-                  const tb = ensureTextBlock()
-                  tb.content = `${tb.content ?? ''}<thinking>`
-                  runningText += '<thinking>'
-                  streamingContentRef.current = runningText
-                  flush()
-                } else if (phase === 'end') {
-                  const tb = ensureTextBlock()
-                  tb.content = `${tb.content ?? ''}</thinking>`
-                  runningText += '</thinking>'
-                  streamingContentRef.current = runningText
-                  flush()
-                } else {
-                  const chunk =
-                    typeof d.data === 'string' ? d.data : (parsed.content as string | undefined)
-                  if (chunk) {
-                    const tb = ensureTextBlock()
-                    tb.content = (tb.content ?? '') + chunk
-                    runningText += chunk
-                    streamingContentRef.current = runningText
-                    flush()
-                  }
-                }
-                break
+              break
+            }
+            case MothershipStreamV1EventType.text: {
+              const payload = getPayloadData(parsed)
+              const chunk = typeof payload.text === 'string' ? payload.text : ''
+              if (chunk) {
+                const contentSource: 'main' | 'subagent' = activeSubagent ? 'subagent' : 'main'
+                const needsBoundaryNewline =
+                  lastContentSource !== null &&
+                  lastContentSource !== contentSource &&
+                  runningText.length > 0 &&
+                  !runningText.endsWith('\n')
+                const tb = ensureTextBlock()
+                const normalizedChunk = needsBoundaryNewline ? `\n${chunk}` : chunk
+                tb.content = (tb.content ?? '') + normalizedChunk
+                if (activeSubagent) tb.subagent = activeSubagent
+                runningText += normalizedChunk
+                lastContentSource = contentSource
+                streamingContentRef.current = runningText
+                flush()
               }
-              case 'tool_generating':
-              case 'tool_call': {
-                const id = parsed.toolCallId
-                const data = getPayloadData(parsed)
-                const name = parsed.toolName || data?.name || 'unknown'
-                const isPartial = data?.partial === true
-                if (!id) break
-
-                if (name === 'tool_search_tool_regex') {
-                  break
-                }
-                const ui = parsed.ui || data?.ui
-                if (ui?.hidden) break
-                const displayTitle = ui?.title || ui?.phaseLabel
-                const phaseLabel = ui?.phaseLabel
-                const args = (data?.arguments ?? data?.input) as Record<string, unknown> | undefined
-                if (!toolMap.has(id)) {
-                  toolMap.set(id, blocks.length)
-                  blocks.push({
-                    type: 'tool_call',
-                    toolCall: {
-                      id,
-                      name,
-                      status: 'executing',
-                      displayTitle,
-                      phaseLabel,
-                      params: args,
-                      calledBy: activeSubagent,
-                    },
-                  })
-                  if (name === 'read' || isResourceToolName(name)) {
-                    if (args) toolArgsMap.set(id, args)
-                  }
-                } else {
-                  const idx = toolMap.get(id)!
-                  const tc = blocks[idx].toolCall
-                  if (tc) {
-                    tc.name = name
-                    if (displayTitle) tc.displayTitle = displayTitle
-                    if (phaseLabel) tc.phaseLabel = phaseLabel
-                    if (args) tc.params = args
-                  }
+              break
+            }
+            case MothershipStreamV1EventType.tool: {
+              const payload = getPayloadData(parsed)
+              const previewPhase =
+                typeof payload.previewPhase === 'string' ? payload.previewPhase : undefined
+              const phase =
+                typeof payload.phase === 'string' ? payload.phase : MothershipStreamV1ToolPhase.call
+              const id =
+                typeof payload.toolCallId === 'string'
+                  ? payload.toolCallId
+                  : typeof payload.id === 'string'
+                    ? payload.id
+                    : undefined
+              if (!id) break
+
+              if (previewPhase) {
+                const sessions = filePreviewSessionsRef.current
+                const prevSession = sessions.get(id) ?? {
+                  toolCallId: id,
+                  fileName: '',
+                  content: '',
                 }
-                flush()
 
-                // TODO: Uncomment when rich UI for Results tab is ready
-                // if (shouldOpenGenericResource(name)) {
-                //   if (!genericEntryMap.has(id)) {
-                //     const entryIdx = appendGenericEntry({
-                //       toolCallId: id,
-                //       toolName: name,
-                //       displayTitle: displayTitle ?? name,
-                //       status: 'executing',
-                //       params: args,
-                //     })
-                //     genericEntryMap.set(id, entryIdx)
-                //     const opened = addResource({ type: 'generic', id: 'results', title: 'Results' })
-                //     if (opened) onResourceEventRef.current?.()
-                //     else setActiveResourceId('results')
-                //   } else {
-                //     const entryIdx = genericEntryMap.get(id)
-                //     if (entryIdx !== undefined) {
-                //       updateGenericEntry(entryIdx, {
-                //         toolName: name,
-                //         ...(displayTitle && { displayTitle }),
-                //         ...(args && { params: args }),
-                //       })
-                //     }
-                //   }
-                // }
-
-                if (
-                  parsed.type === 'tool_call' &&
-                  ui?.clientExecutable &&
-                  isWorkflowToolName(name) &&
-                  !isPartial &&
-                  !clientExecutionStarted.has(id)
-                ) {
-                  clientExecutionStarted.add(id)
-                  const args = data?.arguments ?? data?.input ?? {}
-                  const targetWorkflowId =
-                    typeof (args as Record<string, unknown>).workflowId === 'string'
-                      ? ((args as Record<string, unknown>).workflowId as string)
-                      : useWorkflowRegistry.getState().activeWorkflowId
-                  if (targetWorkflowId) {
-                    const meta = getWorkflowById(workspaceId, targetWorkflowId)
-                    const wasAdded = addResource({
-                      type: 'workflow',
-                      id: targetWorkflowId,
-                      title: meta?.name ?? 'Workflow',
-                    })
-                    if (!wasAdded && activeResourceIdRef.current !== targetWorkflowId) {
-                      setActiveResourceId(targetWorkflowId)
-                    }
-                    onResourceEventRef.current?.()
+                if (previewPhase === 'file_preview_start') {
+                  const nextSession: StreamingFilePreview = {
+                    ...prevSession,
+                    toolCallId: id,
                   }
-                  executeRunToolOnClient(id, name, args as Record<string, unknown>)
+                  sessions.set(id, nextSession)
+                  activeFilePreviewToolCallIdRef.current = id
+                  setStreamingFile(nextSession)
+                  break
                 }
-                break
-              }
-              case 'tool_call_delta': {
-                const id = parsed.toolCallId
-                const delta = typeof parsed.data === 'string' ? parsed.data : ''
-                if (!id || !delta) break
-
-                const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : ''
-                const streamWorkspaceFile =
-                  activeSubagent === 'file_write' || toolName === 'workspace_file'
-
-                if (streamWorkspaceFile) {
-                  let prev = streamingFileRef.current
-                  if (!prev) {
-                    prev = { fileName: '', content: '' }
-                    streamingFileRef.current = prev
-                    setStreamingFile(prev)
-                  }
-                  const raw = prev.content + delta
-                  let fileName = prev.fileName
-                  if (!fileName) {
-                    const m = raw.match(/"fileName"\s*:\s*"([^"]+)"/)
-                    if (m) {
-                      fileName = m[1]
-                    }
+
+                if (previewPhase === 'file_preview_target') {
+                  const target = asPayloadRecord(payload.target)
+                  const nextSession: StreamingFilePreview = {
+                    ...prevSession,
+                    operation:
+                      typeof payload.operation === 'string'
+                        ? payload.operation
+                        : prevSession.operation,
+                    targetKind:
+                      target?.kind === 'new_file' || target?.kind === 'file_id'
+                        ? (target.kind as 'new_file' | 'file_id')
+                        : prevSession.targetKind,
+                    fileId: typeof target?.fileId === 'string' ? target.fileId : prevSession.fileId,
+                    fileName:
+                      typeof target?.fileName === 'string' ? target.fileName : prevSession.fileName,
                   }
-                  const fileIdMatch = raw.match(/"fileId"\s*:\s*"([^"]+)"/)
-                  const matchedResourceId = fileIdMatch?.[1]
-                  if (
-                    matchedResourceId &&
-                    resourcesRef.current.some(
-                      (resource) => resource.type === 'file' && resource.id === matchedResourceId
-                    )
-                  ) {
-                    setActiveResourceId(matchedResourceId)
-                    setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
-                  } else if (fileName || fileIdMatch) {
+                  sessions.set(id, nextSession)
+                  activeFilePreviewToolCallIdRef.current = id
+
+                  if (nextSession.targetKind === 'new_file') {
                     const hasStreamingResource = resourcesRef.current.some(
                       (resource) => resource.id === 'streaming-file'
                     )
@@ -1329,211 +927,339 @@ export function useChat(
                       addResource({
                         type: 'file',
                         id: 'streaming-file',
-                        title: fileName || 'Writing file...',
+                        title: nextSession.fileName || 'Writing file...',
                       })
-                    } else if (fileName) {
-                      setResources((rs) =>
-                        rs.map((resource) =>
-                          resource.id === 'streaming-file'
-                            ? { ...resource, title: fileName }
-                            : resource
-                        )
-                      )
+                      setActiveResourceId('streaming-file')
+                    }
+                  } else if (nextSession.fileId) {
+                    setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
+                    if (
+                      activeResourceIdRef.current === null ||
+                      activeResourceIdRef.current === 'streaming-file'
+                    ) {
+                      setActiveResourceId(nextSession.fileId)
                     }
                   }
-                  const next = { fileName, content: raw }
-                  streamingFileRef.current = next
-                  setStreamingFile(next)
+
+                  setStreamingFile(nextSession)
+                  break
+                }
+
+                if (previewPhase === 'file_preview_edit_meta') {
+                  const nextSession: StreamingFilePreview = {
+                    ...prevSession,
+                    edit: asPayloadRecord(payload.edit),
+                  }
+                  sessions.set(id, nextSession)
+                  activeFilePreviewToolCallIdRef.current = id
+                  setStreamingFile(nextSession)
+                  break
+                }
+
+                if (previewPhase === 'file_preview_content') {
+                  const content = typeof payload.content === 'string' ? payload.content : ''
+                  const isAppendOp = prevSession.operation === 'append'
+                  const prevContent = streamingFileRef.current?.content ?? ''
+                  const nextContent = isAppendOp ? prevContent + content : content
+                  const nextSession: StreamingFilePreview = {
+                    ...prevSession,
+                    content: nextContent,
+                  }
+                  sessions.set(id, nextSession)
+                  activeFilePreviewToolCallIdRef.current = id
+                  streamingFileRef.current = nextSession
+                  setStreamingFile(nextSession)
+                  break
                 }
+              }
+
+              if (phase === MothershipStreamV1ToolPhase.args_delta) {
+                const delta =
+                  typeof payload.argumentsDelta === 'string' ? payload.argumentsDelta : ''
+                if (!delta) break
 
                 const idx = toolMap.get(id)
                 if (idx !== undefined && blocks[idx].toolCall) {
                   const tc = blocks[idx].toolCall!
                   tc.streamingArgs = (tc.streamingArgs ?? '') + delta
-                  flush()
-                }
 
-                // TODO: Uncomment when rich UI for Results tab is ready
-                // if (toolName && shouldOpenGenericResource(toolName)) {
-                //   const entryIdx = genericEntryMap.get(id)
-                //   if (entryIdx !== undefined) {
-                //     const entry = genericResourceDataRef.current.entries[entryIdx]
-                //     if (entry) {
-                //       updateGenericEntry(entryIdx, {
-                //         streamingArgs: (entry.streamingArgs ?? '') + delta,
-                //       })
-                //     }
-                //   }
-                // }
+                  if (tc.name === WorkspaceFile.id) {
+                    const opMatch = tc.streamingArgs.match(/"operation"\s*:\s*"(\w+)"/)
+                    const op = opMatch?.[1] ?? ''
+                    const verb =
+                      op === 'patch' || op === 'update' || op === 'rename'
+                        ? 'Editing'
+                        : op === 'delete'
+                          ? 'Deleting'
+                          : 'Writing'
+                    const titleMatch = tc.streamingArgs.match(/"title"\s*:\s*"([^"]*)"/)
+                    if (titleMatch?.[1]) {
+                      const unescaped = titleMatch[1]
+                        .replace(/\\u([0-9a-fA-F]{4})/g, (_: string, hex: string) =>
+                          String.fromCharCode(Number.parseInt(hex, 16))
+                        )
+                        .replace(/\\"/g, '"')
+                        .replace(/\\\\/g, '\\')
+                      tc.displayTitle = `${verb} ${unescaped}`
+                    }
+                  }
 
+                  flush()
+                }
                 break
               }
-              case 'tool_result': {
-                const id = parsed.toolCallId || getPayloadData(parsed)?.id
-                if (!id) break
+
+              if (phase === MothershipStreamV1ToolPhase.result) {
+                const resultToolName = typeof payload.toolName === 'string' ? payload.toolName : ''
                 const idx = toolMap.get(id)
-                if (idx !== undefined && blocks[idx].toolCall) {
-                  const tc = blocks[idx].toolCall!
+                if (idx === undefined || !blocks[idx].toolCall) {
+                  break
+                }
+                const tc = blocks[idx].toolCall!
+                const resultObj = asPayloadRecord(payload.result)
+                const success =
+                  typeof payload.success === 'boolean'
+                    ? payload.success
+                    : payload.status === MothershipStreamV1ToolOutcome.success
+                const isCancelled =
+                  resultObj?.reason === 'user_cancelled' ||
+                  resultObj?.cancelledByUser === true ||
+                  payload.reason === 'user_cancelled' ||
+                  payload.cancelledByUser === true ||
+                  payload.status === MothershipStreamV1ToolOutcome.cancelled
+
+                if (isCancelled) {
+                  tc.status = 'cancelled'
+                  tc.displayTitle = 'Stopped by user'
+                } else {
+                  tc.status = success ? 'success' : 'error'
+                }
+                tc.streamingArgs = undefined
+                tc.result = {
+                  success: !!success,
+                  output:
+                    payload.result !== undefined
+                      ? payload.result
+                      : payload.output !== undefined
+                        ? payload.output
+                        : payload.data,
+                  error: typeof payload.error === 'string' ? payload.error : undefined,
+                }
+                flush()
 
-                  const payloadData = getPayloadData(parsed)
-                  const resultObj =
-                    parsed.result && typeof parsed.result === 'object'
-                      ? (parsed.result as Record<string, unknown>)
-                      : undefined
-                  const isCancelled =
-                    resultObj?.reason === 'user_cancelled' ||
-                    resultObj?.cancelledByUser === true ||
-                    (payloadData as Record<string, unknown> | undefined)?.reason ===
-                      'user_cancelled' ||
-                    (payloadData as Record<string, unknown> | undefined)?.cancelledByUser === true
-
-                  if (isCancelled) {
-                    tc.status = 'cancelled'
-                    tc.displayTitle = 'Stopped by user'
-                  } else {
-                    tc.status = parsed.success ? 'success' : 'error'
-                  }
-                  tc.streamingArgs = undefined
-                  tc.result = {
-                    success: !!parsed.success,
-                    output: parsed.result ?? getPayloadData(parsed)?.result,
-                    error: (parsed.error ?? getPayloadData(parsed)?.error) as string | undefined,
+                if (tc.name === ReadTool.id && tc.status === 'success') {
+                  const readArgs = toolArgsMap.get(id)
+                  const resource = extractResourceFromReadResult(
+                    readArgs?.path as string | undefined,
+                    tc.result.output
+                  )
+                  if (resource && addResource(resource)) {
+                    onResourceEventRef.current?.()
                   }
-                  flush()
+                }
 
-                  if (tc.name === 'read' && tc.status === 'success') {
-                    const readArgs = toolArgsMap.get(id)
-                    const resource = extractResourceFromReadResult(
-                      readArgs?.path as string | undefined,
-                      tc.result.output
-                    )
-                    if (resource && addResource(resource)) {
-                      onResourceEventRef.current?.()
-                    }
+                if (DEPLOY_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
+                  const output = tc.result?.output as Record<string, unknown> | undefined
+                  const deployedWorkflowId = (output?.workflowId as string) ?? undefined
+                  if (deployedWorkflowId && typeof output?.isDeployed === 'boolean') {
+                    queryClient.invalidateQueries({
+                      queryKey: deploymentKeys.info(deployedWorkflowId),
+                    })
+                    queryClient.invalidateQueries({
+                      queryKey: deploymentKeys.versions(deployedWorkflowId),
+                    })
+                    queryClient.invalidateQueries({
+                      queryKey: workflowKeys.list(workspaceId),
+                    })
                   }
+                }
 
-                  if (DEPLOY_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
-                    const output = tc.result?.output as Record<string, unknown> | undefined
-                    const deployedWorkflowId = (output?.workflowId as string) ?? undefined
-                    if (deployedWorkflowId && typeof output?.isDeployed === 'boolean') {
-                      queryClient.invalidateQueries({
-                        queryKey: deploymentKeys.info(deployedWorkflowId),
-                      })
-                      queryClient.invalidateQueries({
-                        queryKey: deploymentKeys.versions(deployedWorkflowId),
-                      })
-                      queryClient.invalidateQueries({
-                        queryKey: workflowKeys.list(workspaceId),
-                      })
-                    }
-                  }
+                if (FOLDER_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
+                  queryClient.invalidateQueries({
+                    queryKey: folderKeys.list(workspaceId),
+                  })
+                }
+                if (WORKFLOW_MUTATION_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
+                  queryClient.invalidateQueries({
+                    queryKey: workflowKeys.list(workspaceId),
+                  })
+                }
 
-                  const extractedResources =
-                    tc.status === 'success' && isResourceToolName(tc.name)
-                      ? extractResourcesFromToolResult(
-                          tc.name,
-                          toolArgsMap.get(id) as Record<string, unknown> | undefined,
-                          tc.result?.output
-                        )
-                      : []
+                const extractedResources =
+                  tc.status === 'success' && isResourceToolName(tc.name)
+                    ? extractResourcesFromToolResult(
+                        tc.name,
+                        toolArgsMap.get(id) as Record<string, unknown> | undefined,
+                        tc.result?.output
+                      )
+                    : []
 
-                  for (const resource of extractedResources) {
-                    invalidateResourceQueries(queryClient, workspaceId, resource.type, resource.id)
-                  }
+                for (const resource of extractedResources) {
+                  invalidateResourceQueries(queryClient, workspaceId, resource.type, resource.id)
+                }
 
-                  onToolResultRef.current?.(tc.name, tc.status === 'success', tc.result?.output)
+                onToolResultRef.current?.(tc.name, tc.status === 'success', tc.result?.output)
 
-                  if (tc.name === 'workspace_file') {
-                    setStreamingFile(null)
-                    streamingFileRef.current = null
+                if (isWorkflowToolName(tc.name)) {
+                  clientExecutionStartedRef.current.delete(id)
+                }
 
-                    const fileResource = extractedResources.find((r) => r.type === 'file')
-                    if (fileResource) {
-                      setResources((rs) => {
-                        const without = rs.filter((r) => r.id !== 'streaming-file')
-                        if (without.some((r) => r.type === 'file' && r.id === fileResource.id)) {
-                          return without
-                        }
-                        return [...without, fileResource]
-                      })
-                      setActiveResourceId(fileResource.id)
-                    } else {
-                      setResources((rs) => rs.filter((r) => r.id !== 'streaming-file'))
+                if (tc.name === WorkspaceFile.id) {
+                  filePreviewSessionsRef.current.delete(id)
+                  if (activeFilePreviewToolCallIdRef.current === id) {
+                    activeFilePreviewToolCallIdRef.current = null
+                    if (!activeSubagent || activeSubagent !== FileTool.id) {
+                      setStreamingFile(null)
+                      streamingFileRef.current = null
                     }
                   }
-
-                  // TODO: Uncomment when rich UI for Results tab is ready
-                  // if (
-                  //   shouldOpenGenericResource(tc.name) ||
-                  //   (isDeferredResourceTool(tc.name) && extractedResources.length === 0)
-                  // ) {
-                  //   const entryIdx = genericEntryMap.get(id)
-                  //   if (entryIdx !== undefined) {
-                  //     updateGenericEntry(entryIdx, {
-                  //       status: tc.status,
-                  //       result: tc.result ?? undefined,
-                  //       streamingArgs: undefined,
-                  //     })
-                  //   } else {
-                  //     const newIdx = appendGenericEntry({
-                  //       toolCallId: id,
-                  //       toolName: tc.name,
-                  //       displayTitle: tc.displayTitle ?? tc.name,
-                  //       status: tc.status,
-                  //       params: toolArgsMap.get(id) as Record<string, unknown> | undefined,
-                  //       result: tc.result ?? undefined,
-                  //     })
-                  //     genericEntryMap.set(id, newIdx)
-                  //     if (addResource({ type: 'generic', id: 'results', title: 'Results' })) {
-                  //       onResourceEventRef.current?.()
-                  //     }
-                  //   }
-                  // }
+                  const fileResource = extractedResources.find((r) => r.type === 'file')
+                  if (fileResource) {
+                    setResources((rs) => {
+                      const without = rs.filter((r) => r.id !== 'streaming-file')
+                      if (without.some((r) => r.type === 'file' && r.id === fileResource.id)) {
+                        return without
+                      }
+                      return [...without, fileResource]
+                    })
+                    setActiveResourceId(fileResource.id)
+                    invalidateResourceQueries(queryClient, workspaceId, 'file', fileResource.id)
+                  } else if (!activeSubagent || activeSubagent !== FileTool.id) {
+                    setResources((rs) => rs.filter((r) => r.id !== 'streaming-file'))
+                  }
                 }
-
                 break
               }
-              case 'resource_added': {
-                const resource = parsed.resource
-                if (resource?.type && resource?.id) {
-                  const wasAdded = addResource(resource)
-                  invalidateResourceQueries(queryClient, workspaceId, resource.type, resource.id)
 
-                  if (!wasAdded && activeResourceIdRef.current !== resource.id) {
-                    setActiveResourceId(resource.id)
-                  }
-                  onResourceEventRef.current?.()
+              const name =
+                typeof payload.toolName === 'string'
+                  ? payload.toolName
+                  : typeof payload.name === 'string'
+                    ? payload.name
+                    : 'unknown'
+              const isPartial = payload.partial === true
+              if (name === ToolSearchToolRegex.id) {
+                break
+              }
+              const ui = getToolUI(payload)
+              if (ui?.hidden) break
+              let displayTitle = ui?.title || ui?.phaseLabel
+              const phaseLabel = ui?.phaseLabel
+              const args = (asPayloadRecord(payload.arguments) ?? asPayloadRecord(payload.input)) as
+                | Record<string, unknown>
+                | undefined
+
+              if (name === WorkspaceFile.id) {
+                const operation = typeof args?.operation === 'string' ? args.operation : ''
+                const verb =
+                  operation === 'patch' || operation === 'update' || operation === 'rename'
+                    ? 'Editing'
+                    : operation === 'delete'
+                      ? 'Deleting'
+                      : 'Writing'
+                const chunkTitle = args?.title as string | undefined
+                const target = args ? asPayloadRecord(args.target) : undefined
+                const targetFileName = target?.fileName as string | undefined
+                if (chunkTitle) {
+                  displayTitle = `${verb} ${chunkTitle}`
+                } else if (targetFileName) {
+                  displayTitle = `${verb} ${targetFileName}`
+                }
+              }
 
-                  if (resource.type === 'workflow') {
-                    const wasRegistered = ensureWorkflowInRegistry(
-                      resource.id,
-                      resource.title,
-                      workspaceId
-                    )
-                    if (wasAdded && wasRegistered) {
-                      useWorkflowRegistry.getState().setActiveWorkflow(resource.id)
-                    } else {
-                      useWorkflowRegistry.getState().loadWorkflowState(resource.id)
-                    }
-                  }
+              if (!toolMap.has(id)) {
+                toolMap.set(id, blocks.length)
+                blocks.push({
+                  type: 'tool_call',
+                  toolCall: {
+                    id,
+                    name,
+                    status: 'executing',
+                    displayTitle,
+                    phaseLabel,
+                    params: args,
+                    calledBy: activeSubagent,
+                  },
+                })
+                if (name === ReadTool.id || isResourceToolName(name)) {
+                  if (args) toolArgsMap.set(id, args)
+                }
+              } else {
+                const idx = toolMap.get(id)!
+                const tc = blocks[idx].toolCall
+                if (tc) {
+                  tc.name = name
+                  if (displayTitle) tc.displayTitle = displayTitle
+                  if (phaseLabel) tc.phaseLabel = phaseLabel
+                  if (args) tc.params = args
                 }
+              }
+              flush()
+
+              if (isWorkflowToolName(name) && !isPartial) {
+                startClientWorkflowTool(id, name, args ?? {})
+              }
+              break
+            }
+            case MothershipStreamV1EventType.resource: {
+              const payload = getPayloadData(parsed)
+              const resource = asPayloadRecord(payload.resource)
+              if (
+                !resource ||
+                typeof resource.type !== 'string' ||
+                typeof resource.id !== 'string'
+              ) {
                 break
               }
-              case 'resource_deleted': {
-                const resource = parsed.resource
-                if (resource?.type && resource?.id) {
-                  removeResource(resource.type as MothershipResourceType, resource.id)
-                  invalidateResourceQueries(
-                    queryClient,
-                    workspaceId,
-                    resource.type as MothershipResourceType,
-                    resource.id
-                  )
-                  onResourceEventRef.current?.()
-                }
+
+              if (payload.op === MothershipStreamV1ResourceOp.remove) {
+                removeResource(resource.type as MothershipResourceType, resource.id)
+                invalidateResourceQueries(
+                  queryClient,
+                  workspaceId,
+                  resource.type as MothershipResourceType,
+                  resource.id
+                )
+                onResourceEventRef.current?.()
                 break
               }
-              case 'context_compaction_start': {
+
+              const nextResource = {
+                type: resource.type as MothershipResourceType,
+                id: resource.id,
+                title: typeof resource.title === 'string' ? resource.title : resource.id,
+              }
+              const wasAdded = addResource(nextResource)
+              invalidateResourceQueries(
+                queryClient,
+                workspaceId,
+                nextResource.type,
+                nextResource.id
+              )
+
+              if (!wasAdded && activeResourceIdRef.current !== nextResource.id) {
+                setActiveResourceId(nextResource.id)
+              }
+              onResourceEventRef.current?.()
+
+              if (nextResource.type === 'workflow') {
+                const wasRegistered = ensureWorkflowInRegistry(
+                  nextResource.id,
+                  nextResource.title,
+                  workspaceId
+                )
+                if (wasAdded && wasRegistered) {
+                  useWorkflowRegistry.getState().setActiveWorkflow(nextResource.id)
+                } else {
+                  useWorkflowRegistry.getState().loadWorkflowState(nextResource.id)
+                }
+              }
+              break
+            }
+            case MothershipStreamV1EventType.run: {
+              const payload = getPayloadData(parsed)
+              const kind = typeof payload.kind === 'string' ? payload.kind : ''
+              if (kind === MothershipStreamV1RunKind.compaction_start) {
                 const compactionId = `compaction_${Date.now()}`
                 activeCompactionId = compactionId
                 toolMap.set(compactionId, blocks.length)
@@ -1547,9 +1273,7 @@ export function useChat(
                   },
                 })
                 flush()
-                break
-              }
-              case 'context_compaction': {
+              } else if (kind === MothershipStreamV1RunKind.compaction_done) {
                 const compactionId = activeCompactionId || `compaction_${Date.now()}`
                 activeCompactionId = undefined
                 const idx = toolMap.get(compactionId)
@@ -1569,88 +1293,350 @@ export function useChat(
                   })
                 }
                 flush()
+              }
+              break
+            }
+            case MothershipStreamV1EventType.span: {
+              const payload = getPayloadData(parsed)
+              const kind = typeof payload.kind === 'string' ? payload.kind : ''
+              if (kind !== MothershipStreamV1SpanPayloadKind.subagent) {
                 break
               }
-              case 'tool_error': {
-                const id = parsed.toolCallId || getPayloadData(parsed)?.id
-                if (!id) break
-                const idx = toolMap.get(id)
-                if (idx !== undefined && blocks[idx].toolCall) {
-                  const toolCallName = blocks[idx].toolCall!.name
-                  blocks[idx].toolCall!.status = 'error'
-                  if (toolCallName === 'workspace_file') {
-                    setStreamingFile(null)
-                    streamingFileRef.current = null
-                    setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
+              const spanEvent = typeof payload.event === 'string' ? payload.event : ''
+              const spanData = asPayloadRecord(payload.data)
+              const parentToolCallId =
+                typeof parsed.scope?.parentToolCallId === 'string'
+                  ? parsed.scope.parentToolCallId
+                  : typeof spanData?.tool_call_id === 'string'
+                    ? spanData.tool_call_id
+                    : undefined
+              const isPendingPause = spanData?.pending === true
+              const name =
+                typeof payload.agent === 'string'
+                  ? payload.agent
+                  : typeof parsed.scope?.agentId === 'string'
+                    ? parsed.scope.agentId
+                    : undefined
+              if (spanEvent === MothershipStreamV1SpanLifecycleEvent.start && name) {
+                const isSameActiveSubagent =
+                  activeSubagent === name &&
+                  activeSubagentParentToolCallId &&
+                  parentToolCallId === activeSubagentParentToolCallId
+                activeSubagent = name
+                activeSubagentParentToolCallId = parentToolCallId
+                if (!isSameActiveSubagent) {
+                  blocks.push({ type: 'subagent', content: name })
+                }
+                if (name === FileTool.id) {
+                  const emptyFile: StreamingFilePreview = {
+                    toolCallId: parentToolCallId || 'file-preview',
+                    fileName: '',
+                    content: '',
                   }
-                  flush()
+                  streamingFileRef.current = emptyFile
+                  setStreamingFile(emptyFile)
+                }
+                flush()
+              } else if (spanEvent === MothershipStreamV1SpanLifecycleEvent.end) {
+                if (isPendingPause) {
+                  break
+                }
+                if (streamingFileRef.current && !activeFilePreviewToolCallIdRef.current) {
+                  setStreamingFile(null)
+                  streamingFileRef.current = null
+                  const lastFileResource = resourcesRef.current.find(
+                    (r) => r.type === 'file' && r.id !== 'streaming-file'
+                  )
+                  setResources((rs) => rs.filter((r) => r.id !== 'streaming-file'))
+                  if (lastFileResource) {
+                    setActiveResourceId(lastFileResource.id)
+                  }
+                }
+                activeSubagent = undefined
+                activeSubagentParentToolCallId = undefined
+                blocks.push({ type: 'subagent_end' })
+                flush()
+              }
+              break
+            }
+            case MothershipStreamV1EventType.error: {
+              const payload = getPayloadData(parsed)
+              sawStreamError = true
+              setError(
+                (typeof payload.message === 'string' ? payload.message : undefined) ||
+                  (typeof payload.error === 'string' ? payload.error : undefined) ||
+                  'An error occurred'
+              )
+              appendInlineErrorTag(buildInlineErrorTag(parsed))
+              break
+            }
+            case MothershipStreamV1EventType.complete: {
+              sawCompleteEvent = true
+              break
+            }
+          }
+        }
+      } finally {
+        if (streamReaderRef.current === reader) {
+          streamReaderRef.current = null
+        }
+      }
+      return { sawStreamError, sawComplete: sawCompleteEvent }
+    },
+    [workspaceId, queryClient, addResource, removeResource]
+  )
+  processSSEStreamRef.current = processSSEStream
+
+  const getActiveStreamIdForChat = useCallback(
+    async (chatId: string): Promise<string | null> => {
+      const cached = queryClient.getQueryData<TaskChatHistory>(taskKeys.detail(chatId))
+      if (cached?.activeStreamId) {
+        return cached.activeStreamId
+      }
+
+      try {
+        const history = await fetchChatHistory(chatId)
+        queryClient.setQueryData(taskKeys.detail(chatId), history)
+        return history.activeStreamId ?? null
+      } catch (error) {
+        logger.warn('Failed to load chat history while recovering stream', {
+          chatId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+        return null
+      }
+    },
+    [queryClient]
+  )
+
+  const fetchStreamBatch = useCallback(
+    async (
+      streamId: string,
+      afterCursor: string,
+      signal?: AbortSignal
+    ): Promise<StreamBatchResponse> => {
+      const response = await fetch(
+        `/api/copilot/chat/stream?streamId=${encodeURIComponent(streamId)}&after=${encodeURIComponent(afterCursor)}&batch=true`,
+        { signal }
+      )
+      if (!response.ok) {
+        throw new Error(`Stream resume batch failed: ${response.status}`)
+      }
+      return response.json()
+    },
+    []
+  )
+
+  const attachToExistingStream = useCallback(
+    async (opts: {
+      streamId: string
+      assistantId: string
+      expectedGen: number
+      initialBatch?: StreamBatchResponse | null
+      afterCursor?: string
+    }): Promise<{ error: boolean; aborted: boolean }> => {
+      const { streamId, assistantId, expectedGen, afterCursor = '0' } = opts
+      let latestCursor = afterCursor
+      let seedEvents = opts.initialBatch?.events ?? []
+      let streamStatus = opts.initialBatch?.status ?? 'unknown'
+
+      setIsSending(true)
+      setIsReconnecting(true)
+      setError(null)
+
+      try {
+        while (streamGenRef.current === expectedGen) {
+          if (seedEvents.length > 0) {
+            const replayResult = await processSSEStreamRef.current(
+              buildReplayStream(seedEvents).getReader(),
+              assistantId,
+              expectedGen,
+              { preserveExistingState: true }
+            )
+            latestCursor = String(seedEvents[seedEvents.length - 1]?.eventId ?? latestCursor)
+            lastCursorRef.current = latestCursor
+            seedEvents = []
+
+            if (replayResult.sawStreamError) {
+              return { error: true, aborted: false }
+            }
+          }
+
+          if (isTerminalStreamStatus(streamStatus)) {
+            if (streamStatus === 'error') {
+              setError(RECONNECT_TAIL_ERROR)
+            }
+            return { error: streamStatus === 'error', aborted: false }
+          }
+
+          const activeAbort = abortControllerRef.current
+          if (!activeAbort || activeAbort.signal.aborted) {
+            return { error: false, aborted: true }
+          }
+
+          logger.info('Opening live stream tail', { streamId, afterCursor: latestCursor })
+
+          const sseRes = await fetch(
+            `/api/copilot/chat/stream?streamId=${encodeURIComponent(streamId)}&after=${encodeURIComponent(latestCursor)}`,
+            { signal: activeAbort.signal }
+          )
+          if (!sseRes.ok || !sseRes.body) {
+            throw new Error(RECONNECT_TAIL_ERROR)
+          }
+
+          setIsReconnecting(false)
+
+          const liveResult = await processSSEStreamRef.current(
+            sseRes.body.getReader(),
+            assistantId,
+            expectedGen,
+            { preserveExistingState: true }
+          )
 
-                  // TODO: Uncomment when rich UI for Results tab is ready
-                  // if (toolCallName && shouldOpenGenericResource(toolCallName)) {
-                  //   const entryIdx = genericEntryMap.get(id)
-                  //   if (entryIdx !== undefined) {
-                  //     updateGenericEntry(entryIdx, { status: 'error', streamingArgs: undefined })
-                  //   }
-                  // }
-                }
-                break
-              }
-              case 'subagent_start': {
-                const name = parsed.subagent || getPayloadData(parsed)?.agent
-                if (name) {
-                  activeSubagent = name
-                  blocks.push({ type: 'subagent', content: name })
-                  if (name === 'file_write') {
-                    const emptyFile = { fileName: '', content: '' }
-                    // Ref must be updated synchronously: tool_call_delta can arrive before React
-                    // re-renders after setStreamingFile, and the handler only appends when prev exists.
-                    streamingFileRef.current = emptyFile
-                    setStreamingFile(emptyFile)
-                  }
-                  flush()
-                }
-                break
-              }
-              case 'subagent_end': {
-                activeSubagent = undefined
-                blocks.push({ type: 'subagent_end' })
-                flush()
-                break
-              }
-              case 'title_updated': {
-                queryClient.invalidateQueries({
-                  queryKey: taskKeys.list(workspaceId),
-                })
-                onTitleUpdateRef.current?.()
-                break
-              }
-              case 'error': {
-                sawStreamError = true
-                setError(parsed.error || 'An error occurred')
-                appendInlineErrorTag(buildInlineErrorTag(parsed))
-                break
-              }
-              case 'done': {
-                sawDoneEvent = true
-                break
-              }
+          if (liveResult.sawStreamError) {
+            return { error: true, aborted: false }
+          }
+
+          if (liveResult.sawComplete) {
+            return { error: false, aborted: false }
+          }
+
+          setIsReconnecting(true)
+
+          latestCursor = lastCursorRef.current || latestCursor
+
+          logger.warn('Live stream ended without terminal event, fetching batch', {
+            streamId,
+            latestCursor,
+          })
+
+          const batch = await fetchStreamBatch(streamId, latestCursor, activeAbort.signal)
+          seedEvents = batch.events
+          streamStatus = batch.status
+
+          if (batch.events.length > 0) {
+            latestCursor = String(batch.events[batch.events.length - 1].eventId)
+            lastCursorRef.current = latestCursor
+          }
+
+          if (batch.events.length === 0 && !isTerminalStreamStatus(batch.status)) {
+            if (activeAbort.signal.aborted || streamGenRef.current !== expectedGen) {
+              return { error: false, aborted: true }
             }
           }
         }
+
+        return { error: false, aborted: true }
+      } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+          return { error: false, aborted: true }
+        }
+        throw err
       } finally {
-        if (streamReaderRef.current === reader) {
-          streamReaderRef.current = null
+        setIsReconnecting(false)
+      }
+    },
+    [fetchStreamBatch]
+  )
+
+  const resumeOrFinalize = useCallback(
+    async (opts: {
+      streamId: string
+      assistantId: string
+      gen: number
+      afterCursor: string
+      signal?: AbortSignal
+    }): Promise<void> => {
+      const { streamId, assistantId, gen, afterCursor, signal } = opts
+
+      const batch = await fetchStreamBatch(streamId, afterCursor, signal)
+      if (streamGenRef.current !== gen) return
+
+      if (isTerminalStreamStatus(batch.status)) {
+        if (batch.events.length > 0) {
+          await processSSEStreamRef.current(
+            buildReplayStream(batch.events).getReader(),
+            assistantId,
+            gen,
+            { preserveExistingState: true }
+          )
         }
+        finalizeRef.current(batch.status === 'error' ? { error: true } : undefined)
+        return
       }
-      return {
-        sawStreamError,
-        sawDoneEvent,
-        lastEventId,
+
+      const reconnectResult = await attachToExistingStream({
+        streamId,
+        assistantId,
+        expectedGen: gen,
+        initialBatch: batch,
+        afterCursor:
+          batch.events.length > 0
+            ? String(batch.events[batch.events.length - 1].eventId)
+            : afterCursor,
+      })
+
+      if (streamGenRef.current === gen && !reconnectResult.aborted) {
+        finalizeRef.current(reconnectResult.error ? { error: true } : undefined)
       }
     },
-    [workspaceId, queryClient, addResource, removeResource]
+    [fetchStreamBatch, attachToExistingStream]
   )
-  processSSEStreamRef.current = processSSEStream
+
+  const retryReconnect = useCallback(
+    async (opts: { streamId: string; assistantId: string; gen: number }): Promise<boolean> => {
+      const { streamId, assistantId, gen } = opts
+
+      for (let attempt = 0; attempt <= MAX_RECONNECT_ATTEMPTS; attempt++) {
+        if (streamGenRef.current !== gen) return true
+        if (abortControllerRef.current?.signal.aborted) return true
+
+        if (attempt > 0) {
+          const delayMs = Math.min(
+            RECONNECT_BASE_DELAY_MS * 2 ** (attempt - 1),
+            RECONNECT_MAX_DELAY_MS
+          )
+          logger.warn('Reconnect attempt', {
+            streamId,
+            attempt,
+            maxAttempts: MAX_RECONNECT_ATTEMPTS,
+            delayMs,
+          })
+          setIsReconnecting(true)
+          await new Promise((resolve) => setTimeout(resolve, delayMs))
+          if (streamGenRef.current !== gen) return true
+          if (abortControllerRef.current?.signal.aborted) return true
+        }
+
+        try {
+          await resumeOrFinalize({
+            streamId,
+            assistantId,
+            gen,
+            afterCursor: lastCursorRef.current || '0',
+            signal: abortControllerRef.current?.signal,
+          })
+          return true
+        } catch (err) {
+          if (err instanceof Error && err.name === 'AbortError') return true
+          logger.warn('Reconnect attempt failed', {
+            streamId,
+            attempt: attempt + 1,
+            error: err instanceof Error ? err.message : String(err),
+          })
+        }
+      }
+
+      logger.error('All reconnect attempts exhausted', {
+        streamId,
+        maxAttempts: MAX_RECONNECT_ATTEMPTS,
+      })
+      setIsReconnecting(false)
+      return false
+    },
+    [resumeOrFinalize]
+  )
+  retryReconnectRef.current = retryReconnect
 
   const persistPartialResponse = useCallback(async () => {
     const chatId = chatIdRef.current
@@ -1659,7 +1645,7 @@ export function useChat(
 
     const content = streamingContentRef.current
 
-    const storedBlocks: TaskStoredContentBlock[] = streamingBlocksRef.current.map((block) => {
+    const storedBlocks = streamingBlocksRef.current.map((block) => {
       if (block.type === 'tool_call' && block.toolCall) {
         const isCancelled =
           block.toolCall.status === 'executing' || block.toolCall.status === 'cancelled'
@@ -1669,7 +1655,7 @@ export function useChat(
           toolCall: {
             id: block.toolCall.id,
             name: block.toolCall.name,
-            state: isCancelled ? 'cancelled' : block.toolCall.status,
+            state: isCancelled ? MothershipStreamV1ToolOutcome.cancelled : block.toolCall.status,
             params: block.toolCall.params,
             result: block.toolCall.result,
             display: {
@@ -1683,7 +1669,7 @@ export function useChat(
     })
 
     if (storedBlocks.length > 0) {
-      storedBlocks.push({ type: 'stopped' })
+      storedBlocks.push({ type: 'stopped', content: undefined })
     }
 
     try {
@@ -1718,22 +1704,11 @@ export function useChat(
 
   const messagesRef = useRef(messages)
   messagesRef.current = messages
-  const visibleMessageQueue = useMemo(
-    () =>
-      pendingRecoveryMessage
-        ? [
-            pendingRecoveryMessage,
-            ...messageQueue.filter((msg) => msg.id !== pendingRecoveryMessage.id),
-          ]
-        : messageQueue,
-    [messageQueue, pendingRecoveryMessage]
-  )
 
   const finalize = useCallback(
     (options?: { error?: boolean }) => {
       sendingRef.current = false
       setIsSending(false)
-      setIsReconnecting(false)
       abortControllerRef.current = null
       invalidateChatQueries()
 
@@ -1745,27 +1720,10 @@ export function useChat(
       }
 
       if (options?.error) {
-        pendingRecoveryMessageRef.current = null
-        setPendingRecoveryMessage(null)
         setMessageQueue([])
         return
       }
 
-      const recoveryMessage = pendingRecoveryMessageRef.current
-      if (recoveryMessage) {
-        setPendingRecoveryMessage(null)
-        const gen = streamGenRef.current
-        queueMicrotask(() => {
-          if (streamGenRef.current !== gen) return
-          sendMessageRef.current(
-            recoveryMessage.content,
-            recoveryMessage.fileAttachments,
-            recoveryMessage.contexts
-          )
-        })
-        return
-      }
-
       const next = messageQueueRef.current[0]
       if (next) {
         setMessageQueue((prev) => prev.filter((m) => m.id !== next.id))
@@ -1780,108 +1738,6 @@ export function useChat(
   )
   finalizeRef.current = finalize
 
-  const resumeOrFinalize = useCallback(
-    async (opts: {
-      streamId: string
-      assistantId: string
-      gen: number
-      fromEventId: number
-      snapshot?: StreamSnapshot | null
-      signal?: AbortSignal
-    }): Promise<void> => {
-      const { streamId, assistantId, gen, fromEventId, snapshot, signal } = opts
-
-      const batch =
-        snapshot ??
-        (await (async () => {
-          const b = await fetchStreamBatch(streamId, fromEventId, signal)
-          if (streamGenRef.current !== gen) return null
-          return { events: b.events, status: b.status } as StreamSnapshot
-        })())
-
-      if (!batch || streamGenRef.current !== gen) return
-
-      if (isTerminalStreamStatus(batch.status)) {
-        finalize(batch.status === 'error' ? { error: true } : undefined)
-        return
-      }
-
-      const reconnectResult = await attachToExistingStream({
-        streamId,
-        assistantId,
-        expectedGen: gen,
-        snapshot: batch,
-        initialLastEventId: batch.events[batch.events.length - 1]?.eventId ?? fromEventId,
-      })
-
-      if (streamGenRef.current === gen && !reconnectResult.aborted) {
-        finalize(reconnectResult.error ? { error: true } : undefined)
-      }
-    },
-    [fetchStreamBatch, attachToExistingStream, finalize]
-  )
-
-  const retryReconnect = useCallback(
-    async (opts: {
-      streamId: string
-      assistantId: string
-      gen: number
-      initialSnapshot?: StreamSnapshot | null
-    }): Promise<boolean> => {
-      const { streamId, assistantId, gen, initialSnapshot } = opts
-
-      for (let attempt = 0; attempt <= MAX_RECONNECT_ATTEMPTS; attempt++) {
-        if (streamGenRef.current !== gen) return true
-        if (abortControllerRef.current?.signal.aborted) return true
-
-        if (attempt > 0) {
-          const delayMs = Math.min(
-            RECONNECT_BASE_DELAY_MS * 2 ** (attempt - 1),
-            RECONNECT_MAX_DELAY_MS
-          )
-          logger.warn('Reconnect attempt', {
-            streamId,
-            attempt,
-            maxAttempts: MAX_RECONNECT_ATTEMPTS,
-            delayMs,
-          })
-          setIsReconnecting(true)
-          await new Promise((resolve) => setTimeout(resolve, delayMs))
-          if (streamGenRef.current !== gen) return true
-          if (abortControllerRef.current?.signal.aborted) return true
-        }
-
-        try {
-          await resumeOrFinalize({
-            streamId,
-            assistantId,
-            gen,
-            fromEventId: lastEventIdRef.current,
-            snapshot: attempt === 0 ? initialSnapshot : undefined,
-            signal: abortControllerRef.current?.signal,
-          })
-          return true
-        } catch (err) {
-          if (err instanceof Error && err.name === 'AbortError') return true
-          logger.warn('Reconnect attempt failed', {
-            streamId,
-            attempt: attempt + 1,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        }
-      }
-
-      logger.error('All reconnect attempts exhausted', {
-        streamId,
-        maxAttempts: MAX_RECONNECT_ATTEMPTS,
-      })
-      setIsReconnecting(false)
-      return false
-    },
-    [resumeOrFinalize]
-  )
-  retryReconnectRef.current = retryReconnect
-
   const sendMessage = useCallback(
     async (message: string, fileAttachments?: FileAttachmentForApi[], contexts?: ChatContext[]) => {
       if (!message.trim() || !workspaceId) return
@@ -1908,10 +1764,9 @@ export function useChat(
 
       pendingUserMsgRef.current = { id: userMessageId, content: message }
       streamIdRef.current = userMessageId
-      lastEventIdRef.current = 0
-      clientExecutionStartedRef.current.clear()
+      lastCursorRef.current = '0'
 
-      const storedAttachments: TaskStoredFileAttachment[] | undefined =
+      const storedAttachments: PersistedFileAttachment[] | undefined =
         fileAttachments && fileAttachments.length > 0
           ? fileAttachments.map((f) => ({
               id: f.id,
@@ -1923,14 +1778,12 @@ export function useChat(
           : undefined
 
       const requestChatId = selectedChatIdRef.current ?? chatIdRef.current
-      const previousChatHistory = requestChatId
-        ? queryClient.getQueryData<TaskChatHistory>(taskKeys.detail(requestChatId))
-        : undefined
       if (requestChatId) {
-        const cachedUserMsg: TaskStoredMessage = {
+        const cachedUserMsg: PersistedMessage = {
           id: userMessageId,
           role: 'user' as const,
           content: message,
+          timestamp: new Date().toISOString(),
           ...(storedAttachments && { fileAttachments: storedAttachments }),
         }
         queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(requestChatId), (old) => {
@@ -1944,8 +1797,15 @@ export function useChat(
         })
       }
 
-      const userAttachments = storedAttachments?.map(toDisplayAttachment)
-      const previousMessages = messagesRef.current
+      const userAttachments = storedAttachments?.map((f) => ({
+        id: f.id,
+        filename: f.filename,
+        media_type: f.media_type,
+        size: f.size,
+        previewUrl: f.media_type.startsWith('image/')
+          ? `/api/files/serve/${encodeURIComponent(f.key)}?context=mothership`
+          : undefined,
+      }))
 
       const messageContexts = contexts?.map((c) => ({
         kind: c.kind,
@@ -2005,86 +1865,45 @@ export function useChat(
 
         if (!response.ok) {
           const errorData = await response.json().catch(() => ({}))
+          if (response.status === 409) {
+            const conflictStreamId =
+              typeof errorData.activeStreamId === 'string'
+                ? errorData.activeStreamId
+                : userMessageId
+            streamIdRef.current = conflictStreamId
+            const succeeded = await retryReconnect({
+              streamId: conflictStreamId,
+              assistantId,
+              gen,
+            })
+            if (succeeded) return
+            if (streamGenRef.current === gen) {
+              finalize({ error: true })
+            }
+            return
+          }
           throw new Error(errorData.error || `Request failed: ${response.status}`)
         }
 
         if (!response.body) throw new Error('No response body')
 
-        const termination = await processSSEStream(response.body.getReader(), assistantId, {
-          expectedGen: gen,
-        })
+        const streamResult = await processSSEStream(response.body.getReader(), assistantId, gen)
         if (streamGenRef.current === gen) {
-          if (termination.sawStreamError) {
+          if (streamResult.sawStreamError) {
             finalize({ error: true })
             return
           }
 
           await resumeOrFinalize({
-            streamId: userMessageId,
+            streamId: streamIdRef.current || userMessageId,
             assistantId,
             gen,
-            fromEventId: termination.lastEventId,
+            afterCursor: lastCursorRef.current || '0',
             signal: abortController.signal,
           })
         }
       } catch (err) {
         if (err instanceof Error && err.name === 'AbortError') return
-        const errorMessage = err instanceof Error ? err.message : 'Failed to send message'
-        if (requestChatId && isActiveStreamConflictError(errorMessage)) {
-          logger.info('Active stream conflict detected while sending message; reattaching', {
-            chatId: requestChatId,
-            attemptedStreamId: userMessageId,
-          })
-
-          if (previousChatHistory) {
-            queryClient.setQueryData(taskKeys.detail(requestChatId), previousChatHistory)
-          }
-          setMessages(previousMessages)
-          const queuedMessage: QueuedMessage = {
-            id: generateId(),
-            content: message,
-            fileAttachments,
-            contexts,
-          }
-          pendingRecoveryMessageRef.current = queuedMessage
-          setPendingRecoveryMessage(queuedMessage)
-
-          try {
-            const pendingRecovery = await preparePendingStreamRecovery(requestChatId)
-            if (!pendingRecovery) {
-              setError(errorMessage)
-              if (streamGenRef.current === gen) {
-                finalize({ error: true })
-              }
-              return
-            }
-
-            streamIdRef.current = pendingRecovery.streamId
-            lastEventIdRef.current =
-              pendingRecovery.snapshot?.events?.[pendingRecovery.snapshot.events.length - 1]
-                ?.eventId ?? 0
-
-            const rehydratedMessages = messagesRef.current
-            const lastAssistantMsg = [...rehydratedMessages]
-              .reverse()
-              .find((m) => m.role === 'assistant')
-            const recoveryAssistantId = lastAssistantMsg?.id ?? assistantId
-
-            await resumeOrFinalize({
-              streamId: pendingRecovery.streamId,
-              assistantId: recoveryAssistantId,
-              gen,
-              fromEventId: lastEventIdRef.current,
-              snapshot: pendingRecovery.snapshot,
-            })
-            return
-          } catch (recoveryError) {
-            logger.warn('Failed to recover active stream after conflict', {
-              chatId: requestChatId,
-              error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
-            })
-          }
-        }
 
         const activeStreamId = streamIdRef.current
         if (activeStreamId && streamGenRef.current === gen) {
@@ -2096,22 +1915,14 @@ export function useChat(
           if (succeeded) return
         }
 
-        setError(errorMessage)
+        setError(err instanceof Error ? err.message : 'Failed to send message')
         if (streamGenRef.current === gen) {
           finalize({ error: true })
         }
         return
       }
     },
-    [
-      workspaceId,
-      queryClient,
-      processSSEStream,
-      finalize,
-      resumeOrFinalize,
-      retryReconnect,
-      preparePendingStreamRecovery,
-    ]
+    [workspaceId, queryClient, processSSEStream, finalize, resumeOrFinalize, retryReconnect]
   )
   sendMessageRef.current = sendMessage
 
@@ -2130,10 +1941,6 @@ export function useChat(
     abortControllerRef.current = null
     sendingRef.current = false
     setIsSending(false)
-    setIsReconnecting(false)
-    lastEventIdRef.current = 0
-    pendingRecoveryMessageRef.current = null
-    setPendingRecoveryMessage(null)
 
     setMessages((prev) =>
       prev.map((msg) => {
@@ -2175,6 +1982,8 @@ export function useChat(
     invalidateChatQueries()
     setStreamingFile(null)
     streamingFileRef.current = null
+    filePreviewSessionsRef.current.clear()
+    activeFilePreviewToolCallIdRef.current = null
     setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
 
     const execState = useExecutionStore.getState()
@@ -2212,7 +2021,6 @@ export function useChat(
       })
 
       executionStream.cancel(workflowId)
-      consolePersistence.executionEnded()
       execState.setIsExecuting(workflowId, false)
       execState.setIsDebugging(workflowId, false)
       execState.setActiveBlocks(workflowId, new Set())
@@ -2222,47 +2030,24 @@ export function useChat(
   }, [invalidateChatQueries, persistPartialResponse, executionStream])
 
   const removeFromQueue = useCallback((id: string) => {
-    if (pendingRecoveryMessageRef.current?.id === id) {
-      pendingRecoveryMessageRef.current = null
-      setPendingRecoveryMessage(null)
-      return
-    }
     messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
     setMessageQueue((prev) => prev.filter((m) => m.id !== id))
   }, [])
 
   const sendNow = useCallback(
     async (id: string) => {
-      const recoveryMessage = pendingRecoveryMessageRef.current
-      const msg =
-        recoveryMessage?.id === id
-          ? recoveryMessage
-          : messageQueueRef.current.find((m) => m.id === id)
+      const msg = messageQueueRef.current.find((m) => m.id === id)
       if (!msg) return
       // Eagerly update ref so a rapid second click finds the message already gone
-      if (recoveryMessage?.id === id) {
-        pendingRecoveryMessageRef.current = null
-        setPendingRecoveryMessage(null)
-      } else {
-        messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
-      }
+      messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
       await stopGeneration()
-      if (recoveryMessage?.id !== id) {
-        setMessageQueue((prev) => prev.filter((m) => m.id !== id))
-      }
+      setMessageQueue((prev) => prev.filter((m) => m.id !== id))
       await sendMessage(msg.content, msg.fileAttachments, msg.contexts)
     },
     [stopGeneration, sendMessage]
   )
 
   const editQueuedMessage = useCallback((id: string): QueuedMessage | undefined => {
-    const recoveryMessage = pendingRecoveryMessageRef.current
-    if (recoveryMessage?.id === id) {
-      pendingRecoveryMessageRef.current = null
-      setPendingRecoveryMessage(null)
-      return recoveryMessage
-    }
-
     const msg = messageQueueRef.current.find((m) => m.id === id)
     if (!msg) return undefined
     messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
@@ -2276,9 +2061,6 @@ export function useChat(
       abortControllerRef.current = null
       streamGenRef.current++
       sendingRef.current = false
-      lastEventIdRef.current = 0
-      clientExecutionStartedRef.current.clear()
-      pendingRecoveryMessageRef.current = null
     }
   }, [])
 
@@ -2296,7 +2078,7 @@ export function useChat(
     addResource,
     removeResource,
     reorderResources,
-    messageQueue: visibleMessageQueue,
+    messageQueue,
     removeFromQueue,
     sendNow,
     editQueuedMessage,
diff --git a/apps/sim/app/workspace/[workspaceId]/home/types.ts b/apps/sim/app/workspace/[workspaceId]/home/types.ts
index e6ae3c9f0a9..53eb80cda6a 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/types.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/types.ts
@@ -1,10 +1,39 @@
-import type { MothershipResourceType } from '@/lib/copilot/resource-types'
+import {
+  Agent,
+  Auth,
+  CreateWorkflow,
+  Debug,
+  Deploy,
+  EditWorkflow,
+  FunctionExecute,
+  GetPageContents,
+  Glob,
+  Grep,
+  Job,
+  Knowledge,
+  KnowledgeBase,
+  ManageMcpTool,
+  ManageSkill,
+  OpenResource,
+  Read as ReadTool,
+  Research,
+  Run,
+  ScrapePage,
+  SearchLibraryDocs,
+  SearchOnline,
+  Superagent,
+  Table,
+  UserMemory,
+  UserTable,
+  Workflow,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import type { ChatContext } from '@/stores/panel'
 
 export type {
   MothershipResource,
   MothershipResourceType,
-} from '@/lib/copilot/resource-types'
+} from '@/lib/copilot/resources/types'
 
 /** Union of all valid context kind strings, derived from {@link ChatContext}. */
 export type ChatContextKind = ChatContext['kind']
@@ -24,169 +53,34 @@ export interface QueuedMessage {
   contexts?: ChatContext[]
 }
 
-/**
- * SSE event types emitted by the Go orchestrator backend.
- *
- * @example
- * ```json
- * { "type": "content", "data": "Hello world" }
- * { "type": "tool_call", "state": "executing", "toolCallId": "toolu_...", "toolName": "glob", "ui": { "title": "..." } }
- * { "type": "subagent_start", "subagent": "build" }
- * ```
- */
-export type SSEEventType =
-  | 'chat_id'
-  | 'request_id'
-  | 'title_updated'
-  | 'content'
-  | 'reasoning' // openai reasoning - render as thinking text
-  | 'tool_call' // tool call name
-  | 'tool_call_delta' // chunk of tool call
-  | 'tool_generating' // start a tool call
-  | 'tool_result' // tool call result
-  | 'tool_error' // tool call error
-  | 'resource_added' // add a resource to the chat
-  | 'resource_deleted' // delete a resource from the chat
-  | 'subagent_start' // start a subagent
-  | 'subagent_end' // end a subagent
-  | 'structured_result' // structured result from a tool call
-  | 'subagent_result' // result from a subagent
-  | 'done' // end of the chat
-  | 'context_compaction_start' // context compaction started
-  | 'context_compaction' // conversation context was compacted
-  | 'error' // error in the chat
-  | 'start' // start of the chat
-
 /**
  * All tool names observed in the mothership SSE stream, grouped by phase.
  *
  * @example
  * ```json
- * { "type": "tool_generating", "toolName": "glob" }
- * { "type": "tool_call", "toolName": "function_execute", "ui": { "title": "Running code", "icon": "code" } }
- * ```
- */
-export type MothershipToolName =
-  | 'glob'
-  | 'grep'
-  | 'read'
-  | 'search_online'
-  | 'scrape_page'
-  | 'get_page_contents'
-  | 'search_library_docs'
-  | 'manage_mcp_tool'
-  | 'manage_skill'
-  | 'manage_credential'
-  | 'manage_custom_tool'
-  | 'manage_job'
-  | 'user_memory'
-  | 'function_execute'
-  | 'superagent'
-  | 'user_table'
-  | 'workspace_file'
-  | 'create_workflow'
-  | 'delete_workflow'
-  | 'edit_workflow'
-  | 'rename_workflow'
-  | 'move_workflow'
-  | 'run_workflow'
-  | 'run_block'
-  | 'run_from_block'
-  | 'run_workflow_until_block'
-  | 'create_folder'
-  | 'delete_folder'
-  | 'move_folder'
-  | 'list_folders'
-  | 'list_user_workspaces'
-  | 'create_job'
-  | 'complete_job'
-  | 'update_job_history'
-  | 'job_respond'
-  | 'download_to_workspace_file'
-  | 'materialize_file'
-  | 'context_write'
-  | 'generate_image'
-  | 'generate_visualization'
-  | 'crawl_website'
-  | 'get_execution_summary'
-  | 'get_job_logs'
-  | 'get_deployment_version'
-  | 'revert_to_version'
-  | 'check_deployment_status'
-  | 'get_deployed_workflow_state'
-  | 'get_workflow_data'
-  | 'get_workflow_logs'
-  | 'get_block_outputs'
-  | 'get_block_upstream_references'
-  | 'set_global_workflow_variables'
-  | 'set_environment_variables'
-  | 'get_platform_actions'
-  | 'search_documentation'
-  | 'search_patterns'
-  | 'update_workspace_mcp_server'
-  | 'delete_workspace_mcp_server'
-  | 'create_workspace_mcp_server'
-  | 'list_workspace_mcp_servers'
-  | 'deploy_api'
-  | 'deploy_chat'
-  | 'deploy_mcp'
-  | 'redeploy'
-  | 'generate_api_key'
-  | 'oauth_get_auth_link'
-  | 'oauth_request_access'
-  | 'build'
-  | 'run'
-  | 'deploy'
-  | 'auth'
-  | 'knowledge'
-  | 'knowledge_base'
-  | 'table'
-  | 'job'
-  | 'agent'
-  | 'custom_tool'
-  | 'research'
-  | 'plan'
-  | 'debug'
-  | 'edit'
-  | 'fast_edit'
-  | 'open_resource'
-  | 'context_compaction'
-
-/**
- * Subagent identifiers dispatched via `subagent_start` SSE events.
- *
- * @example
- * ```json
- * { "type": "subagent_start", "subagent": "build" }
+ * { "type": "tool", "phase": "call", "toolName": "glob" }
+ * { "type": "tool", "phase": "call", "toolName": "function_execute", "ui": { "title": "Running code", "icon": "code" } }
  * ```
+ * Stream `type` is `MothershipStreamV1EventType.tool` (`mothership-stream-v1`) with `phase: 'call'`.
  */
-export type SubagentName =
-  | 'build'
-  | 'deploy'
-  | 'auth'
-  | 'research'
-  | 'knowledge'
-  | 'table'
-  | 'custom_tool'
-  | 'superagent'
-  | 'plan'
-  | 'debug'
-  | 'edit'
-  | 'fast_edit'
-  | 'run'
-  | 'agent'
-  | 'job'
-  | 'file_write'
 
-export type ToolPhase =
-  | 'workspace'
-  | 'search'
-  | 'management'
-  | 'execution'
-  | 'resource'
-  | 'subagent'
+export const ToolPhase = {
+  workspace: 'workspace',
+  search: 'search',
+  management: 'management',
+  execution: 'execution',
+  resource: 'resource',
+  subagent: 'subagent',
+} as const
+export type ToolPhase = (typeof ToolPhase)[keyof typeof ToolPhase]
 
-export type ToolCallStatus = 'executing' | 'success' | 'error' | 'cancelled'
+export const ToolCallStatus = {
+  executing: 'executing',
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
+export type ToolCallStatus = (typeof ToolCallStatus)[keyof typeof ToolCallStatus]
 
 export interface ToolCallResult {
   success: boolean
@@ -194,7 +88,6 @@ export interface ToolCallResult {
   error?: string
 }
 
-/** A single tool call result entry in the generic Results resource tab. */
 export interface GenericResourceEntry {
   toolCallId: string
   toolName: string
@@ -205,7 +98,6 @@ export interface GenericResourceEntry {
   result?: ToolCallResult
 }
 
-/** Accumulated feed of tool call results shown in the generic Results tab. */
 export interface GenericResourceData {
   entries: GenericResourceEntry[]
 }
@@ -228,7 +120,7 @@ export interface ToolCallInfo {
   phaseLabel?: string
   params?: Record<string, unknown>
   calledBy?: string
-  result?: { success: boolean; output?: unknown; error?: string }
+  result?: ToolCallResult
   streamingArgs?: string
 }
 
@@ -237,14 +129,16 @@ export interface OptionItem {
   label: string
 }
 
-export type ContentBlockType =
-  | 'text'
-  | 'tool_call'
-  | 'subagent'
-  | 'subagent_end'
-  | 'subagent_text'
-  | 'options'
-  | 'stopped'
+export const ContentBlockType = {
+  text: 'text',
+  tool_call: 'tool_call',
+  subagent: 'subagent',
+  subagent_end: 'subagent_end',
+  subagent_text: 'subagent_text',
+  options: 'options',
+  stopped: 'stopped',
+} as const
+export type ContentBlockType = (typeof ContentBlockType)[keyof typeof ContentBlockType]
 
 export interface ContentBlock {
   type: ContentBlockType
@@ -283,8 +177,8 @@ export interface ChatMessage {
   requestId?: string
 }
 
-export const SUBAGENT_LABELS: Record<SubagentName, string> = {
-  build: 'Build agent',
+export const SUBAGENT_LABELS: Record<string, string> = {
+  workflow: 'Workflow agent',
   deploy: 'Deploy agent',
   auth: 'Integration agent',
   research: 'Research agent',
@@ -292,14 +186,11 @@ export const SUBAGENT_LABELS: Record<SubagentName, string> = {
   table: 'Table agent',
   custom_tool: 'Custom Tool agent',
   superagent: 'Superagent',
-  plan: 'Plan agent',
   debug: 'Debug agent',
-  edit: 'Edit agent',
-  fast_edit: 'Build agent',
   run: 'Run agent',
   agent: 'Agent manager',
   job: 'Job agent',
-  file_write: 'File Write',
+  file: 'File',
 } as const
 
 export interface ToolUIMetadata {
@@ -309,206 +200,123 @@ export interface ToolUIMetadata {
 }
 
 /**
- * Primary UI metadata for tools observed in the SSE stream.
- * Maps tool IDs to human-readable display names shown in the chat.
- * This is the single source of truth — server-sent `ui.title` values are not used.
+ * Default UI metadata for tools observed in the SSE stream.
+ * The backend may send `ui` on some `MothershipStreamV1EventType.tool` payloads (`phase: 'call'`);
+ * this map provides fallback metadata when `ui` is absent.
  */
-export const TOOL_UI_METADATA: Record<MothershipToolName, ToolUIMetadata> = {
-  // Workspace
-  glob: { title: 'Searching workspace', phaseLabel: 'Workspace', phase: 'workspace' },
-  grep: { title: 'Searching workspace', phaseLabel: 'Workspace', phase: 'workspace' },
-  read: { title: 'Reading file', phaseLabel: 'Workspace', phase: 'workspace' },
-  // Search
-  search_online: { title: 'Searching online', phaseLabel: 'Search', phase: 'search' },
-  scrape_page: { title: 'Reading webpage', phaseLabel: 'Search', phase: 'search' },
-  get_page_contents: { title: 'Reading page', phaseLabel: 'Search', phase: 'search' },
-  search_library_docs: { title: 'Searching docs', phaseLabel: 'Search', phase: 'search' },
-  crawl_website: { title: 'Browsing website', phaseLabel: 'Search', phase: 'search' },
-  // Execution
-  function_execute: { title: 'Running code', phaseLabel: 'Code', phase: 'execution' },
-  superagent: { title: 'Taking action', phaseLabel: 'Action', phase: 'execution' },
-  run_workflow: { title: 'Running workflow', phaseLabel: 'Execution', phase: 'execution' },
-  run_block: { title: 'Running block', phaseLabel: 'Execution', phase: 'execution' },
-  run_from_block: { title: 'Running from block', phaseLabel: 'Execution', phase: 'execution' },
-  run_workflow_until_block: {
-    title: 'Running partial workflow',
-    phaseLabel: 'Execution',
-    phase: 'execution',
+export const TOOL_UI_METADATA: Record<string, ToolUIMetadata> = {
+  [Glob.id]: {
+    title: 'Searching files',
+    phaseLabel: 'Workspace',
+    phase: 'workspace',
   },
-  complete_job: { title: 'Completing job', phaseLabel: 'Execution', phase: 'execution' },
-  get_execution_summary: { title: 'Checking results', phaseLabel: 'Execution', phase: 'execution' },
-  get_job_logs: { title: 'Checking logs', phaseLabel: 'Execution', phase: 'execution' },
-  get_workflow_logs: { title: 'Checking logs', phaseLabel: 'Execution', phase: 'execution' },
-  get_workflow_data: { title: 'Loading workflow', phaseLabel: 'Execution', phase: 'execution' },
-  get_block_outputs: {
-    title: 'Checking block outputs',
-    phaseLabel: 'Execution',
-    phase: 'execution',
+  [Grep.id]: {
+    title: 'Searching code',
+    phaseLabel: 'Workspace',
+    phase: 'workspace',
   },
-  get_block_upstream_references: {
-    title: 'Checking references',
-    phaseLabel: 'Execution',
-    phase: 'execution',
+  [ReadTool.id]: { title: 'Reading file', phaseLabel: 'Workspace', phase: 'workspace' },
+  [SearchOnline.id]: {
+    title: 'Searching online',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [ScrapePage.id]: {
+    title: 'Scraping page',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [GetPageContents.id]: {
+    title: 'Getting page contents',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [SearchLibraryDocs.id]: {
+    title: 'Searching library docs',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [ManageMcpTool.id]: {
+    title: 'Managing MCP tool',
+    phaseLabel: 'Management',
+    phase: 'management',
   },
-  get_deployed_workflow_state: {
-    title: 'Checking deployment',
-    phaseLabel: 'Execution',
+  [ManageSkill.id]: {
+    title: 'Managing skill',
+    phaseLabel: 'Management',
+    phase: 'management',
+  },
+  [UserMemory.id]: {
+    title: 'Accessing memory',
+    phaseLabel: 'Management',
+    phase: 'management',
+  },
+  [FunctionExecute.id]: {
+    title: 'Running code',
+    phaseLabel: 'Code',
     phase: 'execution',
   },
-  check_deployment_status: {
-    title: 'Checking deployment',
-    phaseLabel: 'Execution',
+  [Superagent.id]: {
+    title: 'Executing action',
+    phaseLabel: 'Action',
     phase: 'execution',
   },
-  // Workflows & folders
-  create_workflow: { title: 'Creating workflow', phaseLabel: 'Resource', phase: 'resource' },
-  delete_workflow: { title: 'Deleting workflow', phaseLabel: 'Resource', phase: 'resource' },
-  edit_workflow: { title: 'Editing workflow', phaseLabel: 'Resource', phase: 'resource' },
-  rename_workflow: { title: 'Renaming workflow', phaseLabel: 'Resource', phase: 'resource' },
-  move_workflow: { title: 'Moving workflow', phaseLabel: 'Resource', phase: 'resource' },
-  create_folder: { title: 'Creating folder', phaseLabel: 'Resource', phase: 'resource' },
-  delete_folder: { title: 'Deleting folder', phaseLabel: 'Resource', phase: 'resource' },
-  move_folder: { title: 'Moving folder', phaseLabel: 'Resource', phase: 'resource' },
-  list_folders: { title: 'Browsing folders', phaseLabel: 'Resource', phase: 'resource' },
-  list_user_workspaces: { title: 'Browsing workspaces', phaseLabel: 'Resource', phase: 'resource' },
-  revert_to_version: { title: 'Restoring version', phaseLabel: 'Resource', phase: 'resource' },
-  get_deployment_version: {
-    title: 'Checking deployment',
+  [UserTable.id]: {
+    title: 'Managing table',
     phaseLabel: 'Resource',
     phase: 'resource',
   },
-  open_resource: { title: 'Opening resource', phaseLabel: 'Resource', phase: 'resource' },
-  // Files
-  workspace_file: { title: 'Working with files', phaseLabel: 'Resource', phase: 'resource' },
-  download_to_workspace_file: {
-    title: 'Downloading file',
+  [WorkspaceFile.id]: {
+    title: 'Managing file',
     phaseLabel: 'Resource',
     phase: 'resource',
   },
-  materialize_file: { title: 'Saving file', phaseLabel: 'Resource', phase: 'resource' },
-  generate_image: { title: 'Generating image', phaseLabel: 'Resource', phase: 'resource' },
-  generate_visualization: {
-    title: 'Generating visualization',
+  [CreateWorkflow.id]: {
+    title: 'Creating workflow',
     phaseLabel: 'Resource',
     phase: 'resource',
   },
-  // Tables & knowledge
-  user_table: { title: 'Editing table', phaseLabel: 'Resource', phase: 'resource' },
-  knowledge_base: { title: 'Updating knowledge base', phaseLabel: 'Resource', phase: 'resource' },
-  // Jobs
-  create_job: { title: 'Creating job', phaseLabel: 'Resource', phase: 'resource' },
-  manage_job: { title: 'Updating job', phaseLabel: 'Management', phase: 'management' },
-  update_job_history: { title: 'Updating job', phaseLabel: 'Management', phase: 'management' },
-  job_respond: { title: 'Explaining job scheduled', phaseLabel: 'Execution', phase: 'execution' },
-  // Management
-  manage_mcp_tool: { title: 'Updating integration', phaseLabel: 'Management', phase: 'management' },
-  manage_skill: { title: 'Updating skill', phaseLabel: 'Management', phase: 'management' },
-  manage_credential: { title: 'Connecting account', phaseLabel: 'Management', phase: 'management' },
-  manage_custom_tool: { title: 'Updating tool', phaseLabel: 'Management', phase: 'management' },
-  update_workspace_mcp_server: {
-    title: 'Updating MCP server',
-    phaseLabel: 'Management',
-    phase: 'management',
-  },
-  delete_workspace_mcp_server: {
-    title: 'Removing MCP server',
-    phaseLabel: 'Management',
-    phase: 'management',
-  },
-  create_workspace_mcp_server: {
-    title: 'Creating MCP server',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [EditWorkflow.id]: {
+    title: 'Editing workflow',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  list_workspace_mcp_servers: {
-    title: 'Browsing MCP servers',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Workflow.id]: { title: 'Managing workflow', phaseLabel: 'Workflow', phase: 'subagent' },
+  [Run.id]: { title: 'Running', phaseLabel: 'Run', phase: 'subagent' },
+  [Deploy.id]: { title: 'Deploying', phaseLabel: 'Deploy', phase: 'subagent' },
+  [Auth.id]: {
+    title: 'Connecting credentials',
+    phaseLabel: 'Auth',
+    phase: 'subagent',
   },
-  oauth_get_auth_link: {
-    title: 'Connecting account',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Knowledge.id]: {
+    title: 'Managing knowledge',
+    phaseLabel: 'Knowledge',
+    phase: 'subagent',
   },
-  oauth_request_access: {
-    title: 'Connecting account',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [KnowledgeBase.id]: {
+    title: 'Managing knowledge base',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  set_environment_variables: {
-    title: 'Updating environment',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Table.id]: { title: 'Managing tables', phaseLabel: 'Table', phase: 'subagent' },
+  [Job.id]: { title: 'Managing jobs', phaseLabel: 'Job', phase: 'subagent' },
+  [Agent.id]: { title: 'Agent action', phaseLabel: 'Agent', phase: 'subagent' },
+  custom_tool: {
+    title: 'Creating tool',
+    phaseLabel: 'Tool',
+    phase: 'subagent',
   },
-  set_global_workflow_variables: {
-    title: 'Updating variables',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Research.id]: { title: 'Researching', phaseLabel: 'Research', phase: 'subagent' },
+  [Debug.id]: { title: 'Debugging', phaseLabel: 'Debug', phase: 'subagent' },
+  [OpenResource.id]: {
+    title: 'Opening resource',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  get_platform_actions: { title: 'Loading actions', phaseLabel: 'Management', phase: 'management' },
-  search_documentation: { title: 'Searching docs', phaseLabel: 'Search', phase: 'search' },
-  search_patterns: { title: 'Searching patterns', phaseLabel: 'Search', phase: 'search' },
-  deploy_api: { title: 'Deploying API', phaseLabel: 'Deploy', phase: 'management' },
-  deploy_chat: { title: 'Deploying chat', phaseLabel: 'Deploy', phase: 'management' },
-  deploy_mcp: { title: 'Deploying MCP', phaseLabel: 'Deploy', phase: 'management' },
-  redeploy: { title: 'Redeploying', phaseLabel: 'Deploy', phase: 'management' },
-  generate_api_key: { title: 'Generating API key', phaseLabel: 'Deploy', phase: 'management' },
-  user_memory: { title: 'Updating memory', phaseLabel: 'Management', phase: 'management' },
-  context_write: { title: 'Writing notes', phaseLabel: 'Management', phase: 'management' },
   context_compaction: {
-    title: 'Optimizing context',
-    phaseLabel: 'Management',
+    title: 'Compacted context',
+    phaseLabel: 'Context',
     phase: 'management',
   },
-  // Subagents
-  build: { title: 'Building', phaseLabel: 'Build', phase: 'subagent' },
-  run: { title: 'Running', phaseLabel: 'Run', phase: 'subagent' },
-  deploy: { title: 'Deploying', phaseLabel: 'Deploy', phase: 'subagent' },
-  auth: { title: 'Connecting integration', phaseLabel: 'Auth', phase: 'subagent' },
-  knowledge: { title: 'Working with knowledge', phaseLabel: 'Knowledge', phase: 'subagent' },
-  table: { title: 'Working with tables', phaseLabel: 'Table', phase: 'subagent' },
-  job: { title: 'Working with jobs', phaseLabel: 'Job', phase: 'subagent' },
-  agent: { title: 'Taking action', phaseLabel: 'Agent', phase: 'subagent' },
-  custom_tool: { title: 'Creating tool', phaseLabel: 'Tool', phase: 'subagent' },
-  research: { title: 'Researching', phaseLabel: 'Research', phase: 'subagent' },
-  plan: { title: 'Planning', phaseLabel: 'Plan', phase: 'subagent' },
-  debug: { title: 'Debugging', phaseLabel: 'Debug', phase: 'subagent' },
-  edit: { title: 'Editing workflow', phaseLabel: 'Edit', phase: 'subagent' },
-  fast_edit: { title: 'Editing workflow', phaseLabel: 'Edit', phase: 'subagent' },
-}
-
-export interface SSEPayloadUI {
-  hidden?: boolean
-  title?: string
-  phaseLabel?: string
-  icon?: string
-  internal?: boolean
-  clientExecutable?: boolean
-}
-
-export interface SSEPayloadData {
-  name?: string
-  ui?: SSEPayloadUI
-  id?: string
-  agent?: string
-  partial?: boolean
-  arguments?: Record<string, unknown>
-  input?: Record<string, unknown>
-  result?: unknown
-  error?: string
-}
-
-export interface SSEPayload {
-  type: SSEEventType | (string & {})
-  chatId?: string
-  data?: string | SSEPayloadData
-  content?: string
-  toolCallId?: string
-  toolName?: string
-  ui?: SSEPayloadUI
-  success?: boolean
-  result?: unknown
-  error?: string
-  subagent?: string
-  resource?: { type: MothershipResourceType; id: string; title: string }
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx
index da51910789b..5051fb83178 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx
@@ -224,7 +224,7 @@ export const Panel = memo(function Panel({ workspaceId: propWorkspaceId }: Panel
   const [copilotChatId, setCopilotChatId] = useState<string | undefined>(undefined)
   const [copilotChatTitle, setCopilotChatTitle] = useState<string | null>(null)
   const [copilotChatList, setCopilotChatList] = useState<
-    { id: string; title: string | null; updatedAt: string; conversationId: string | null }[]
+    { id: string; title: string | null; updatedAt: string; activeStreamId: string | null }[]
   >([])
   const [isCopilotHistoryOpen, setIsCopilotHistoryOpen] = useState(false)
 
@@ -244,7 +244,7 @@ export const Panel = memo(function Panel({ workspaceId: propWorkspaceId }: Panel
           id: string
           title: string | null
           updatedAt: string
-          conversationId: string | null
+          activeStreamId: string | null
         }>
         setCopilotChatList(filtered)
 
@@ -813,7 +813,7 @@ export const Panel = memo(function Panel({ workspaceId: propWorkspaceId }: Panel
                                   >
                                     <ConversationListItem
                                       title={chat.title || 'New Chat'}
-                                      isActive={Boolean(chat.conversationId)}
+                                      isActive={Boolean(chat.activeStreamId)}
                                       titleClassName='text-[13px]'
                                       actions={
                                         <div
diff --git a/apps/sim/hooks/queries/tasks.ts b/apps/sim/hooks/queries/tasks.ts
index 9cd1eab999a..b68662902b1 100644
--- a/apps/sim/hooks/queries/tasks.ts
+++ b/apps/sim/hooks/queries/tasks.ts
@@ -1,5 +1,7 @@
 import { keepPreviousData, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
-import type { ChatContextKind, MothershipResource } from '@/app/workspace/[workspaceId]/home/types'
+import type { PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+import { normalizeMessage } from '@/lib/copilot/chat/persisted-message'
+import type { MothershipResource } from '@/app/workspace/[workspaceId]/home/types'
 
 export interface TaskMetadata {
   id: string
@@ -9,72 +11,13 @@ export interface TaskMetadata {
   isUnread: boolean
 }
 
-export interface StreamSnapshot {
-  events: Array<{ eventId: number; streamId: string; event: Record<string, unknown> }>
-  status: string
-}
-
 export interface TaskChatHistory {
   id: string
   title: string | null
-  messages: TaskStoredMessage[]
+  messages: PersistedMessage[]
   activeStreamId: string | null
   resources: MothershipResource[]
-  streamSnapshot?: StreamSnapshot | null
-}
-
-export interface TaskStoredToolCall {
-  id: string
-  name: string
-  status: string
-  params?: Record<string, unknown>
-  result?: unknown
-  error?: string
-  durationMs?: number
-}
-
-export interface TaskStoredFileAttachment {
-  id: string
-  key: string
-  filename: string
-  media_type: string
-  size: number
-}
-
-export interface TaskStoredMessageContext {
-  kind: ChatContextKind
-  label: string
-  workflowId?: string
-  knowledgeId?: string
-  tableId?: string
-  fileId?: string
-  folderId?: string
-  chatId?: string
-}
-
-export interface TaskStoredMessage {
-  id: string
-  role: 'user' | 'assistant'
-  content: string
-  requestId?: string
-  toolCalls?: TaskStoredToolCall[]
-  contentBlocks?: TaskStoredContentBlock[]
-  fileAttachments?: TaskStoredFileAttachment[]
-  contexts?: TaskStoredMessageContext[]
-}
-
-export interface TaskStoredContentBlock {
-  type: string
-  content?: string
-  toolCall?: {
-    id?: string
-    name?: string
-    state?: string
-    params?: Record<string, unknown>
-    result?: { success: boolean; output?: unknown; error?: string }
-    display?: { text?: string }
-    calledBy?: string
-  } | null
+  streamSnapshot?: { events: unknown[]; status: string } | null
 }
 
 export const taskKeys = {
@@ -89,7 +32,7 @@ interface TaskResponse {
   id: string
   title: string | null
   updatedAt: string
-  conversationId: string | null
+  activeStreamId: string | null
   lastSeenAt: string | null
 }
 
@@ -99,9 +42,9 @@ function mapTask(chat: TaskResponse): TaskMetadata {
     id: chat.id,
     name: chat.title ?? 'New task',
     updatedAt,
-    isActive: chat.conversationId !== null,
+    isActive: chat.activeStreamId !== null,
     isUnread:
-      chat.conversationId === null &&
+      chat.activeStreamId === null &&
       (chat.lastSeenAt === null || updatedAt > new Date(chat.lastSeenAt)),
   }
 }
@@ -161,10 +104,11 @@ export async function fetchChatHistory(
   return {
     id: chat.id,
     title: chat.title,
-    messages: Array.isArray(chat.messages) ? chat.messages : [],
-    activeStreamId: chat.conversationId || null,
+    messages: Array.isArray(chat.messages)
+      ? chat.messages.map((m: Record<string, unknown>) => normalizeMessage(m))
+      : [],
+    activeStreamId: chat.activeStreamId || null,
     resources: Array.isArray(chat.resources) ? chat.resources : [],
-    streamSnapshot: chat.streamSnapshot || null,
   }
 }
 
diff --git a/apps/sim/lib/copilot/async-runs/lifecycle.ts b/apps/sim/lib/copilot/async-runs/lifecycle.ts
index 949ff773247..2656f7473aa 100644
--- a/apps/sim/lib/copilot/async-runs/lifecycle.ts
+++ b/apps/sim/lib/copilot/async-runs/lifecycle.ts
@@ -1,13 +1,7 @@
 import type { CopilotAsyncToolStatus } from '@sim/db/schema'
+import { MothershipStreamV1AsyncToolRecordStatus } from '@/lib/copilot/generated/mothership-stream-v1'
 
-export const ASYNC_TOOL_STATUS = {
-  pending: 'pending',
-  running: 'running',
-  completed: 'completed',
-  failed: 'failed',
-  cancelled: 'cancelled',
-  delivered: 'delivered',
-} as const
+export const ASYNC_TOOL_STATUS = MothershipStreamV1AsyncToolRecordStatus
 
 export type AsyncLifecycleStatus =
   | typeof ASYNC_TOOL_STATUS.pending
diff --git a/apps/sim/lib/copilot/chat-context.ts b/apps/sim/lib/copilot/chat-context.ts
deleted file mode 100644
index f475b3b2802..00000000000
--- a/apps/sim/lib/copilot/chat-context.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { CopilotFiles } from '@/lib/uploads'
-import { createFileContent } from '@/lib/uploads/utils/file-utils'
-
-const logger = createLogger('CopilotChatContext')
-
-export interface FileAttachmentInput {
-  id: string
-  key: string
-  name?: string
-  filename?: string
-  mimeType?: string
-  media_type?: string
-  size: number
-}
-
-export interface FileContent {
-  type: string
-  [key: string]: unknown
-}
-
-/**
- * Process file attachments into content for the payload.
- */
-export async function processFileAttachments(
-  fileAttachments: FileAttachmentInput[],
-  userId: string
-): Promise<FileContent[]> {
-  if (!Array.isArray(fileAttachments) || fileAttachments.length === 0) return []
-
-  const processedFileContents: FileContent[] = []
-  const requestId = `copilot-${userId}-${Date.now()}`
-  const processedAttachments = await CopilotFiles.processCopilotAttachments(
-    fileAttachments as Parameters<typeof CopilotFiles.processCopilotAttachments>[0],
-    requestId
-  )
-
-  for (const { buffer, attachment } of processedAttachments) {
-    const fileContent = createFileContent(buffer, attachment.media_type)
-    if (fileContent) {
-      const enriched: FileContent = { ...fileContent, filename: attachment.filename }
-      processedFileContents.push(enriched)
-    }
-  }
-
-  logger.debug('Processed file attachments for payload', {
-    userId,
-    inputCount: fileAttachments.length,
-    outputCount: processedFileContents.length,
-  })
-
-  return processedFileContents
-}
diff --git a/apps/sim/lib/copilot/chat-streaming.test.ts b/apps/sim/lib/copilot/chat-streaming.test.ts
deleted file mode 100644
index b0e05ed445a..00000000000
--- a/apps/sim/lib/copilot/chat-streaming.test.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const {
-  orchestrateCopilotStream,
-  createRunSegment,
-  updateRunStatus,
-  resetStreamBuffer,
-  setStreamMeta,
-  createStreamEventWriter,
-} = vi.hoisted(() => ({
-  orchestrateCopilotStream: vi.fn(),
-  createRunSegment: vi.fn(),
-  updateRunStatus: vi.fn(),
-  resetStreamBuffer: vi.fn(),
-  setStreamMeta: vi.fn(),
-  createStreamEventWriter: vi.fn(),
-}))
-
-vi.mock('@/lib/copilot/orchestrator', () => ({
-  orchestrateCopilotStream,
-}))
-
-vi.mock('@/lib/copilot/async-runs/repository', () => ({
-  createRunSegment,
-  updateRunStatus,
-}))
-
-vi.mock('@/lib/copilot/orchestrator/stream/buffer', () => ({
-  createStreamEventWriter,
-  resetStreamBuffer,
-  setStreamMeta,
-}))
-
-vi.mock('@sim/db', () => ({
-  db: {
-    update: vi.fn(() => ({
-      set: vi.fn(() => ({
-        where: vi.fn(),
-      })),
-    })),
-  },
-}))
-
-vi.mock('@/lib/copilot/task-events', () => ({
-  taskPubSub: null,
-}))
-
-import { createSSEStream } from '@/lib/copilot/chat-streaming'
-
-async function drainStream(stream: ReadableStream) {
-  const reader = stream.getReader()
-  while (true) {
-    const { done } = await reader.read()
-    if (done) break
-  }
-}
-
-describe('createSSEStream terminal error handling', () => {
-  const write = vi.fn().mockResolvedValue({ eventId: 1, streamId: 'stream-1', event: {} })
-  const flush = vi.fn().mockResolvedValue(undefined)
-  const close = vi.fn().mockResolvedValue(undefined)
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    write.mockResolvedValue({ eventId: 1, streamId: 'stream-1', event: {} })
-    flush.mockResolvedValue(undefined)
-    close.mockResolvedValue(undefined)
-    createStreamEventWriter.mockReturnValue({ write, flush, close })
-    resetStreamBuffer.mockResolvedValue(undefined)
-    setStreamMeta.mockResolvedValue(undefined)
-    createRunSegment.mockResolvedValue(null)
-    updateRunStatus.mockResolvedValue(null)
-  })
-
-  it('writes a terminal error event before close when orchestration returns success=false', async () => {
-    orchestrateCopilotStream.mockResolvedValue({
-      success: false,
-      error: 'resume failed',
-      content: '',
-      contentBlocks: [],
-      toolCalls: [],
-    })
-
-    const stream = createSSEStream({
-      requestPayload: { message: 'hello' },
-      userId: 'user-1',
-      streamId: 'stream-1',
-      executionId: 'exec-1',
-      runId: 'run-1',
-      currentChat: null,
-      isNewChat: false,
-      message: 'hello',
-      titleModel: 'gpt-5.4',
-      requestId: 'req-1',
-      orchestrateOptions: {},
-    })
-
-    await drainStream(stream)
-
-    expect(write).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'error',
-        error: 'resume failed',
-      })
-    )
-    expect(write.mock.invocationCallOrder.at(-1)).toBeLessThan(close.mock.invocationCallOrder[0])
-  })
-
-  it('writes the thrown terminal error event before close for replay durability', async () => {
-    orchestrateCopilotStream.mockRejectedValue(new Error('kaboom'))
-
-    const stream = createSSEStream({
-      requestPayload: { message: 'hello' },
-      userId: 'user-1',
-      streamId: 'stream-1',
-      executionId: 'exec-1',
-      runId: 'run-1',
-      currentChat: null,
-      isNewChat: false,
-      message: 'hello',
-      titleModel: 'gpt-5.4',
-      requestId: 'req-1',
-      orchestrateOptions: {},
-    })
-
-    await drainStream(stream)
-
-    expect(write).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'error',
-        error: 'kaboom',
-      })
-    )
-    expect(write.mock.invocationCallOrder.at(-1)).toBeLessThan(close.mock.invocationCallOrder[0])
-  })
-})
diff --git a/apps/sim/lib/copilot/chat-streaming.ts b/apps/sim/lib/copilot/chat-streaming.ts
deleted file mode 100644
index 5779d20f65f..00000000000
--- a/apps/sim/lib/copilot/chat-streaming.ts
+++ /dev/null
@@ -1,579 +0,0 @@
-import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { createRunSegment, updateRunStatus } from '@/lib/copilot/async-runs/repository'
-import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import type { OrchestrateStreamOptions } from '@/lib/copilot/orchestrator'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import {
-  createStreamEventWriter,
-  getStreamMeta,
-  resetStreamBuffer,
-  setStreamMeta,
-} from '@/lib/copilot/orchestrator/stream/buffer'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { env } from '@/lib/core/config/env'
-import { acquireLock, getRedisClient, releaseLock } from '@/lib/core/config/redis'
-import { SSE_HEADERS } from '@/lib/core/utils/sse'
-
-const logger = createLogger('CopilotChatStreaming')
-const CHAT_STREAM_LOCK_TTL_SECONDS = 2 * 60 * 60
-const STREAM_ABORT_TTL_SECONDS = 10 * 60
-const STREAM_ABORT_POLL_MS = 1000
-
-interface ActiveStreamEntry {
-  abortController: AbortController
-  userStopController: AbortController
-}
-
-const activeStreams = new Map<string, ActiveStreamEntry>()
-
-// Tracks in-flight streams by chatId so that a subsequent request for the
-// same chat can force-abort the previous stream and wait for it to settle
-// before forwarding to Go.
-const pendingChatStreams = new Map<
-  string,
-  { promise: Promise<void>; resolve: () => void; streamId: string }
->()
-
-function registerPendingChatStream(chatId: string, streamId: string): void {
-  if (pendingChatStreams.has(chatId)) {
-    logger.warn(`registerPendingChatStream: overwriting existing entry for chatId ${chatId}`)
-  }
-  let resolve!: () => void
-  const promise = new Promise<void>((r) => {
-    resolve = r
-  })
-  pendingChatStreams.set(chatId, { promise, resolve, streamId })
-}
-
-function resolvePendingChatStream(chatId: string, streamId: string): void {
-  const entry = pendingChatStreams.get(chatId)
-  if (entry && entry.streamId === streamId) {
-    entry.resolve()
-    pendingChatStreams.delete(chatId)
-  }
-}
-
-function getChatStreamLockKey(chatId: string): string {
-  return `copilot:chat-stream-lock:${chatId}`
-}
-
-function getStreamAbortKey(streamId: string): string {
-  return `copilot:stream-abort:${streamId}`
-}
-
-/**
- * Wait for any in-flight stream on `chatId` to settle without force-aborting it.
- * Returns true when no stream is active (or it settles in time), false on timeout.
- */
-export async function waitForPendingChatStream(
-  chatId: string,
-  timeoutMs = 5_000,
-  expectedStreamId?: string
-): Promise<boolean> {
-  const redis = getRedisClient()
-  const deadline = Date.now() + timeoutMs
-
-  for (;;) {
-    const entry = pendingChatStreams.get(chatId)
-    const localPending = !!entry && (!expectedStreamId || entry.streamId === expectedStreamId)
-
-    if (redis) {
-      try {
-        const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
-        const lockReleased =
-          !ownerStreamId || (expectedStreamId !== undefined && ownerStreamId !== expectedStreamId)
-        if (!localPending && lockReleased) {
-          return true
-        }
-      } catch (error) {
-        logger.warn('Failed to check distributed chat stream lock while waiting', {
-          chatId,
-          expectedStreamId,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    } else if (!localPending) {
-      return true
-    }
-
-    if (Date.now() >= deadline) return false
-    await new Promise((resolve) => setTimeout(resolve, 200))
-  }
-}
-
-export async function releasePendingChatStream(chatId: string, streamId: string): Promise<void> {
-  const redis = getRedisClient()
-  if (redis) {
-    await releaseLock(getChatStreamLockKey(chatId), streamId).catch(() => false)
-  }
-  resolvePendingChatStream(chatId, streamId)
-}
-
-export async function acquirePendingChatStream(
-  chatId: string,
-  streamId: string,
-  timeoutMs = 5_000
-): Promise<boolean> {
-  const redis = getRedisClient()
-  if (redis) {
-    const deadline = Date.now() + timeoutMs
-    for (;;) {
-      try {
-        const acquired = await acquireLock(
-          getChatStreamLockKey(chatId),
-          streamId,
-          CHAT_STREAM_LOCK_TTL_SECONDS
-        )
-        if (acquired) {
-          registerPendingChatStream(chatId, streamId)
-          return true
-        }
-        if (!pendingChatStreams.has(chatId)) {
-          const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
-          if (ownerStreamId) {
-            const ownerMeta = await getStreamMeta(ownerStreamId)
-            const ownerTerminal =
-              ownerMeta?.status === 'complete' ||
-              ownerMeta?.status === 'error' ||
-              ownerMeta?.status === 'cancelled'
-            if (ownerTerminal) {
-              await releaseLock(getChatStreamLockKey(chatId), ownerStreamId).catch(() => false)
-              continue
-            }
-          }
-        }
-      } catch (error) {
-        logger.warn('Distributed chat stream lock failed; retrying distributed coordination', {
-          chatId,
-          streamId,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-      if (Date.now() >= deadline) return false
-      await new Promise((resolve) => setTimeout(resolve, 200))
-    }
-  }
-
-  for (;;) {
-    const existing = pendingChatStreams.get(chatId)
-    if (!existing) {
-      registerPendingChatStream(chatId, streamId)
-      return true
-    }
-
-    const settled = await Promise.race([
-      existing.promise.then(() => true),
-      new Promise<boolean>((r) => setTimeout(() => r(false), timeoutMs)),
-    ])
-    if (!settled) return false
-  }
-}
-
-export async function abortActiveStream(streamId: string): Promise<boolean> {
-  const redis = getRedisClient()
-  let published = false
-  if (redis) {
-    try {
-      await redis.set(getStreamAbortKey(streamId), '1', 'EX', STREAM_ABORT_TTL_SECONDS)
-      published = true
-    } catch (error) {
-      logger.warn('Failed to publish distributed stream abort', {
-        streamId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-  }
-  const entry = activeStreams.get(streamId)
-  if (!entry) return published
-  entry.userStopController.abort()
-  entry.abortController.abort()
-  activeStreams.delete(streamId)
-  return true
-}
-
-const FLUSH_EVENT_TYPES = new Set([
-  'tool_call',
-  'tool_result',
-  'tool_error',
-  'subagent_end',
-  'structured_result',
-  'subagent_result',
-  'done',
-  'error',
-])
-
-export async function requestChatTitle(params: {
-  message: string
-  model: string
-  provider?: string
-  messageId?: string
-}): Promise<string | null> {
-  const { message, model, provider, messageId } = params
-  if (!message || !model) return null
-
-  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
-  if (env.COPILOT_API_KEY) {
-    headers['x-api-key'] = env.COPILOT_API_KEY
-  }
-
-  try {
-    const response = await fetch(`${SIM_AGENT_API_URL}/api/generate-chat-title`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ message, model, ...(provider ? { provider } : {}) }),
-    })
-
-    const payload = await response.json().catch(() => ({}))
-    if (!response.ok) {
-      logger.withMetadata({ messageId }).warn('Failed to generate chat title via copilot backend', {
-        status: response.status,
-        error: payload,
-      })
-      return null
-    }
-
-    const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
-    return title || null
-  } catch (error) {
-    logger.withMetadata({ messageId }).error('Error generating chat title', error)
-    return null
-  }
-}
-
-export interface StreamingOrchestrationParams {
-  requestPayload: Record<string, unknown>
-  userId: string
-  streamId: string
-  executionId: string
-  runId: string
-  chatId?: string
-  currentChat: any
-  isNewChat: boolean
-  message: string
-  titleModel: string
-  titleProvider?: string
-  requestId: string
-  workspaceId?: string
-  orchestrateOptions: Omit<OrchestrateStreamOptions, 'onEvent'>
-  pendingChatStreamAlreadyRegistered?: boolean
-}
-
-export function createSSEStream(params: StreamingOrchestrationParams): ReadableStream {
-  const {
-    requestPayload,
-    userId,
-    streamId,
-    executionId,
-    runId,
-    chatId,
-    currentChat,
-    isNewChat,
-    message,
-    titleModel,
-    titleProvider,
-    requestId,
-    workspaceId,
-    orchestrateOptions,
-    pendingChatStreamAlreadyRegistered = false,
-  } = params
-  const messageId =
-    typeof requestPayload.messageId === 'string' ? requestPayload.messageId : streamId
-  const reqLogger = logger.withMetadata({ requestId, messageId })
-
-  let eventWriter: ReturnType<typeof createStreamEventWriter> | null = null
-  let clientDisconnected = false
-  const abortController = new AbortController()
-  const userStopController = new AbortController()
-  const clientDisconnectedController = new AbortController()
-  activeStreams.set(streamId, { abortController, userStopController })
-
-  if (chatId && !pendingChatStreamAlreadyRegistered) {
-    registerPendingChatStream(chatId, streamId)
-  }
-
-  return new ReadableStream({
-    async start(controller) {
-      const encoder = new TextEncoder()
-      const markClientDisconnected = (reason: string) => {
-        if (clientDisconnected) return
-        clientDisconnected = true
-        if (!clientDisconnectedController.signal.aborted) {
-          clientDisconnectedController.abort()
-        }
-        reqLogger.info('Client disconnected from live SSE stream', {
-          streamId,
-          runId,
-          reason,
-        })
-      }
-
-      await resetStreamBuffer(streamId)
-      await setStreamMeta(streamId, { status: 'active', userId, executionId, runId })
-      if (chatId) {
-        await createRunSegment({
-          id: runId,
-          executionId,
-          chatId,
-          userId,
-          workflowId: (requestPayload.workflowId as string | undefined) || null,
-          workspaceId,
-          streamId,
-          model: (requestPayload.model as string | undefined) || null,
-          provider: (requestPayload.provider as string | undefined) || null,
-          requestContext: { requestId },
-        }).catch((error) => {
-          reqLogger.warn('Failed to create copilot run segment', {
-            error: error instanceof Error ? error.message : String(error),
-          })
-        })
-      }
-      eventWriter = createStreamEventWriter(streamId)
-
-      let localSeq = 0
-      let abortPoller: ReturnType<typeof setInterval> | null = null
-
-      const redis = getRedisClient()
-      if (redis) {
-        abortPoller = setInterval(() => {
-          void (async () => {
-            try {
-              const shouldAbort = await redis.get(getStreamAbortKey(streamId))
-              if (shouldAbort && !abortController.signal.aborted) {
-                userStopController.abort()
-                abortController.abort()
-                await redis.del(getStreamAbortKey(streamId))
-              }
-            } catch (error) {
-              reqLogger.warn('Failed to poll distributed stream abort', {
-                streamId,
-                error: error instanceof Error ? error.message : String(error),
-              })
-            }
-          })()
-        }, STREAM_ABORT_POLL_MS)
-      }
-
-      const pushEvent = async (event: Record<string, any>) => {
-        if (!eventWriter) return
-
-        const eventId = ++localSeq
-
-        try {
-          await eventWriter.write(event)
-          if (FLUSH_EVENT_TYPES.has(event.type)) {
-            await eventWriter.flush()
-          }
-        } catch (error) {
-          reqLogger.error('Failed to persist stream event', {
-            eventType: event.type,
-            eventId,
-            error: error instanceof Error ? error.message : String(error),
-          })
-          // Keep the live SSE stream going even if durable buffering hiccups.
-        }
-
-        try {
-          if (!clientDisconnected) {
-            controller.enqueue(
-              encoder.encode(`data: ${JSON.stringify({ ...event, eventId, streamId })}\n\n`)
-            )
-          }
-        } catch {
-          markClientDisconnected('enqueue_failed')
-        }
-      }
-
-      const pushEventBestEffort = async (event: Record<string, any>) => {
-        try {
-          await pushEvent(event)
-        } catch (error) {
-          reqLogger.error('Failed to push event', {
-            eventType: event.type,
-            error: error instanceof Error ? error.message : String(error),
-          })
-        }
-      }
-
-      if (chatId) {
-        await pushEvent({ type: 'chat_id', chatId })
-      }
-
-      if (chatId && !currentChat?.title && isNewChat) {
-        requestChatTitle({ message, model: titleModel, provider: titleProvider, messageId })
-          .then(async (title) => {
-            if (title) {
-              await db.update(copilotChats).set({ title }).where(eq(copilotChats.id, chatId!))
-              await pushEvent({ type: 'title_updated', title })
-              if (workspaceId) {
-                taskPubSub?.publishStatusChanged({ workspaceId, chatId: chatId!, type: 'renamed' })
-              }
-            }
-          })
-          .catch((error) => {
-            reqLogger.error('Title generation failed', error)
-          })
-      }
-
-      const keepaliveInterval = setInterval(() => {
-        if (clientDisconnected) return
-        try {
-          controller.enqueue(encoder.encode(': keepalive\n\n'))
-        } catch {
-          markClientDisconnected('keepalive_failed')
-        }
-      }, 15_000)
-
-      try {
-        const result = await orchestrateCopilotStream(requestPayload, {
-          ...orchestrateOptions,
-          executionId,
-          runId,
-          abortSignal: abortController.signal,
-          userStopSignal: userStopController.signal,
-          clientDisconnectedSignal: clientDisconnectedController.signal,
-          onEvent: async (event) => {
-            await pushEvent(event)
-          },
-        })
-
-        if (abortController.signal.aborted) {
-          reqLogger.info('Stream aborted by explicit stop')
-          await eventWriter.close().catch(() => {})
-          await setStreamMeta(streamId, { status: 'cancelled', userId, executionId, runId })
-          await updateRunStatus(runId, 'cancelled', { completedAt: new Date() }).catch(() => {})
-          return
-        }
-
-        if (!result.success) {
-          const errorMessage =
-            result.error ||
-            result.errors?.[0] ||
-            'An unexpected error occurred while processing the response.'
-
-          if (clientDisconnected) {
-            reqLogger.info('Stream failed after client disconnect', {
-              error: errorMessage,
-            })
-          }
-
-          reqLogger.error('Orchestration returned failure', {
-            error: errorMessage,
-          })
-          await pushEventBestEffort({
-            type: 'error',
-            error: errorMessage,
-            data: {
-              displayMessage: errorMessage,
-            },
-          })
-          await eventWriter.close()
-          await setStreamMeta(streamId, {
-            status: 'error',
-            userId,
-            executionId,
-            runId,
-            error: errorMessage,
-          })
-          await updateRunStatus(runId, 'error', {
-            completedAt: new Date(),
-            error: errorMessage,
-          }).catch(() => {})
-          return
-        }
-
-        await eventWriter.close()
-        await setStreamMeta(streamId, { status: 'complete', userId, executionId, runId })
-        await updateRunStatus(runId, 'complete', { completedAt: new Date() }).catch(() => {})
-        if (clientDisconnected) {
-          reqLogger.info('Orchestration completed after client disconnect', {
-            streamId,
-            runId,
-          })
-        }
-      } catch (error) {
-        if (abortController.signal.aborted) {
-          reqLogger.info('Stream aborted by explicit stop')
-          await eventWriter.close().catch(() => {})
-          await setStreamMeta(streamId, { status: 'cancelled', userId, executionId, runId })
-          await updateRunStatus(runId, 'cancelled', { completedAt: new Date() }).catch(() => {})
-          return
-        }
-        if (clientDisconnected) {
-          reqLogger.info('Stream errored after client disconnect', {
-            error: error instanceof Error ? error.message : 'Stream error',
-          })
-        }
-        reqLogger.error('Orchestration error', error)
-        const errorMessage = error instanceof Error ? error.message : 'Stream error'
-        await pushEventBestEffort({
-          type: 'error',
-          error: errorMessage,
-          data: {
-            displayMessage: 'An unexpected error occurred while processing the response.',
-          },
-        })
-        await eventWriter.close()
-        await setStreamMeta(streamId, {
-          status: 'error',
-          userId,
-          executionId,
-          runId,
-          error: errorMessage,
-        })
-        await updateRunStatus(runId, 'error', {
-          completedAt: new Date(),
-          error: errorMessage,
-        }).catch(() => {})
-      } finally {
-        reqLogger.info('Closing live SSE stream', {
-          streamId,
-          runId,
-          clientDisconnected,
-          aborted: abortController.signal.aborted,
-        })
-        clearInterval(keepaliveInterval)
-        if (abortPoller) {
-          clearInterval(abortPoller)
-        }
-        activeStreams.delete(streamId)
-        if (chatId) {
-          if (redis) {
-            await releaseLock(getChatStreamLockKey(chatId), streamId).catch(() => false)
-          }
-          resolvePendingChatStream(chatId, streamId)
-        }
-        if (redis) {
-          await redis.del(getStreamAbortKey(streamId)).catch(() => {})
-        }
-        try {
-          controller.close()
-        } catch {
-          // Controller already closed from cancel() — safe to ignore
-        }
-      }
-    },
-    cancel() {
-      reqLogger.info('ReadableStream cancel received from client', {
-        streamId,
-        runId,
-      })
-      if (!clientDisconnected) {
-        clientDisconnected = true
-        if (!clientDisconnectedController.signal.aborted) {
-          clientDisconnectedController.abort()
-        }
-      }
-      if (eventWriter) {
-        eventWriter.flush().catch(() => {})
-      }
-    },
-  })
-}
-
-export const SSE_RESPONSE_HEADERS = {
-  ...SSE_HEADERS,
-  'Content-Encoding': 'none',
-} as const
diff --git a/apps/sim/lib/copilot/chat/display-message.test.ts b/apps/sim/lib/copilot/chat/display-message.test.ts
new file mode 100644
index 00000000000..90648027a4a
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/display-message.test.ts
@@ -0,0 +1,63 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import { toDisplayMessage } from './display-message'
+
+describe('display-message', () => {
+  it('maps canonical tool, subagent text, and cancelled complete blocks to display blocks', () => {
+    const display = toDisplayMessage({
+      id: 'msg-1',
+      role: 'assistant',
+      content: 'done',
+      timestamp: '2024-01-01T00:00:00.000Z',
+      requestId: 'req-1',
+      contentBlocks: [
+        {
+          type: 'tool',
+          phase: 'call',
+          toolCall: {
+            id: 'tool-1',
+            name: 'read',
+            state: 'cancelled',
+            display: { title: 'Stopped by user' },
+          },
+        },
+        {
+          type: 'text',
+          lane: 'subagent',
+          channel: 'assistant',
+          content: 'subagent output',
+        },
+        {
+          type: 'complete',
+          status: 'cancelled',
+        },
+      ],
+    })
+
+    expect(display.contentBlocks).toEqual([
+      {
+        type: 'tool_call',
+        toolCall: {
+          id: 'tool-1',
+          name: 'read',
+          status: 'cancelled',
+          displayTitle: 'Stopped by user',
+          phaseLabel: undefined,
+          params: undefined,
+          calledBy: undefined,
+          result: undefined,
+        },
+      },
+      {
+        type: 'subagent_text',
+        content: 'subagent output',
+      },
+      {
+        type: 'stopped',
+      },
+    ])
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/display-message.ts b/apps/sim/lib/copilot/chat/display-message.ts
new file mode 100644
index 00000000000..b3e6ea3a6cc
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/display-message.ts
@@ -0,0 +1,121 @@
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  type ChatContextKind,
+  type ChatMessage,
+  type ChatMessageAttachment,
+  type ChatMessageContext,
+  type ContentBlock,
+  ContentBlockType,
+  type ToolCallInfo,
+  ToolCallStatus,
+} from '@/app/workspace/[workspaceId]/home/types'
+import type { PersistedContentBlock, PersistedMessage } from './persisted-message'
+
+const STATE_TO_STATUS: Record<string, ToolCallStatus> = {
+  [MothershipStreamV1ToolOutcome.success]: ToolCallStatus.success,
+  [MothershipStreamV1ToolOutcome.error]: ToolCallStatus.error,
+  [MothershipStreamV1ToolOutcome.cancelled]: ToolCallStatus.cancelled,
+  [MothershipStreamV1ToolOutcome.rejected]: ToolCallStatus.error,
+  [MothershipStreamV1ToolOutcome.skipped]: ToolCallStatus.success,
+  pending: ToolCallStatus.executing,
+  executing: ToolCallStatus.executing,
+}
+
+function toToolCallInfo(block: PersistedContentBlock): ToolCallInfo | undefined {
+  const tc = block.toolCall
+  if (!tc) return undefined
+  const status: ToolCallStatus = STATE_TO_STATUS[tc.state] ?? ToolCallStatus.error
+  return {
+    id: tc.id,
+    name: tc.name,
+    status,
+    displayTitle: status === ToolCallStatus.cancelled ? 'Stopped by user' : tc.display?.title,
+    phaseLabel: tc.display?.phaseLabel,
+    params: tc.params,
+    calledBy: tc.calledBy,
+    result: tc.result,
+  }
+}
+
+function toDisplayBlock(block: PersistedContentBlock): ContentBlock {
+  switch (block.type) {
+    case MothershipStreamV1EventType.text:
+      if (block.lane === 'subagent') {
+        return { type: ContentBlockType.subagent_text, content: block.content }
+      }
+      return { type: ContentBlockType.text, content: block.content }
+    case MothershipStreamV1EventType.tool:
+      return { type: ContentBlockType.tool_call, toolCall: toToolCallInfo(block) }
+    case MothershipStreamV1EventType.span:
+      if (block.lifecycle === MothershipStreamV1SpanLifecycleEvent.end) {
+        return { type: ContentBlockType.subagent_end }
+      }
+      return { type: ContentBlockType.subagent, content: block.content }
+    case MothershipStreamV1EventType.complete:
+      if (block.status === MothershipStreamV1CompletionStatus.cancelled) {
+        return { type: ContentBlockType.stopped }
+      }
+      return { type: ContentBlockType.text, content: block.content }
+    default:
+      return { type: ContentBlockType.text, content: block.content }
+  }
+}
+
+function toDisplayAttachment(f: PersistedMessage['fileAttachments']): ChatMessageAttachment[] {
+  if (!f || f.length === 0) return []
+  return f.map((a) => ({
+    id: a.id,
+    filename: a.filename,
+    media_type: a.media_type,
+    size: a.size,
+    previewUrl: a.media_type.startsWith('image/')
+      ? `/api/files/serve/${encodeURIComponent(a.key)}?context=mothership`
+      : undefined,
+  }))
+}
+
+function toDisplayContexts(
+  contexts: PersistedMessage['contexts']
+): ChatMessageContext[] | undefined {
+  if (!contexts || contexts.length === 0) return undefined
+  return contexts.map((c) => ({
+    kind: c.kind as ChatContextKind,
+    label: c.label,
+    ...(c.workflowId ? { workflowId: c.workflowId } : {}),
+    ...(c.knowledgeId ? { knowledgeId: c.knowledgeId } : {}),
+    ...(c.tableId ? { tableId: c.tableId } : {}),
+    ...(c.fileId ? { fileId: c.fileId } : {}),
+    ...(c.folderId ? { folderId: c.folderId } : {}),
+    ...(c.chatId ? { chatId: c.chatId } : {}),
+  }))
+}
+
+export function toDisplayMessage(msg: PersistedMessage): ChatMessage {
+  const display: ChatMessage = {
+    id: msg.id,
+    role: msg.role,
+    content: msg.content,
+  }
+
+  if (msg.requestId) {
+    display.requestId = msg.requestId
+  }
+
+  if (msg.contentBlocks && msg.contentBlocks.length > 0) {
+    display.contentBlocks = msg.contentBlocks.map(toDisplayBlock)
+  }
+
+  const attachments = toDisplayAttachment(msg.fileAttachments)
+  if (attachments.length > 0) {
+    display.attachments = attachments
+  }
+
+  display.contexts = toDisplayContexts(msg.contexts)
+
+  return display
+}
diff --git a/apps/sim/lib/copilot/chat-lifecycle.ts b/apps/sim/lib/copilot/chat/lifecycle.ts
similarity index 100%
rename from apps/sim/lib/copilot/chat-lifecycle.ts
rename to apps/sim/lib/copilot/chat/lifecycle.ts
diff --git a/apps/sim/lib/copilot/chat-payload.test.ts b/apps/sim/lib/copilot/chat/payload.test.ts
similarity index 80%
rename from apps/sim/lib/copilot/chat-payload.test.ts
rename to apps/sim/lib/copilot/chat/payload.test.ts
index 0c7b187e7fd..521509fe48d 100644
--- a/apps/sim/lib/copilot/chat-payload.test.ts
+++ b/apps/sim/lib/copilot/chat/payload.test.ts
@@ -17,10 +17,6 @@ vi.mock('@/lib/billing/core/subscription', () => ({
   getUserSubscriptionState: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/chat-context', () => ({
-  processFileAttachments: vi.fn(),
-}))
-
 vi.mock('@/lib/core/config/feature-flags', () => ({
   isHosted: false,
 }))
@@ -45,6 +41,12 @@ vi.mock('@/tools/registry', () => ({
       name: 'Brandfetch Search',
       description: 'Search for brands by company name',
     },
+    // Catalog marks run_workflow as client / clientExecutable; registry ToolConfig has no executor fields.
+    run_workflow: {
+      id: 'run_workflow',
+      name: 'Run Workflow',
+      description: 'Run a workflow from the client',
+    },
   },
 }))
 
@@ -58,7 +60,7 @@ vi.mock('@/tools/params', () => ({
 }))
 
 import { getUserSubscriptionState } from '@/lib/billing/core/subscription'
-import { buildIntegrationToolSchemas } from '@/lib/copilot/chat-payload'
+import { buildIntegrationToolSchemas } from './payload'
 
 const mockedGetUserSubscriptionState = getUserSubscriptionState as unknown as {
   mockResolvedValue: (value: unknown) => void
@@ -102,4 +104,15 @@ describe('buildIntegrationToolSchemas', () => {
     expect(gmailTool?.description).toBe('Send emails using Gmail')
     expect(brandfetchTool?.description).toBe('Search for brands by company name')
   })
+
+  it('emits executeLocally for dynamic client tools only', async () => {
+    mockedGetUserSubscriptionState.mockResolvedValue({ isFree: false })
+
+    const toolSchemas = await buildIntegrationToolSchemas('user-client')
+    const gmailTool = toolSchemas.find((tool) => tool.name === 'gmail_send')
+    const runTool = toolSchemas.find((tool) => tool.name === 'run_workflow')
+
+    expect(gmailTool?.executeLocally).toBe(false)
+    expect(runTool?.executeLocally).toBe(true)
+  })
 })
diff --git a/apps/sim/lib/copilot/chat-payload.ts b/apps/sim/lib/copilot/chat/payload.ts
similarity index 80%
rename from apps/sim/lib/copilot/chat-payload.ts
rename to apps/sim/lib/copilot/chat/payload.ts
index 69b1d342f17..35dc2bc6637 100644
--- a/apps/sim/lib/copilot/chat-payload.ts
+++ b/apps/sim/lib/copilot/chat/payload.ts
@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { getUserSubscriptionState } from '@/lib/billing/core/subscription'
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { getToolEntry } from '@/lib/copilot/tool-executor/router'
+import { getCopilotToolDescription } from '@/lib/copilot/tools/descriptions'
 import { isHosted } from '@/lib/core/config/feature-flags'
 import { createMcpToolId } from '@/lib/mcp/utils'
 import { trackChatUpload } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
@@ -10,7 +11,7 @@ import { getLatestVersionTools, stripVersionSuffix } from '@/tools/utils'
 
 const logger = createLogger('CopilotChatPayload')
 
-export interface BuildPayloadParams {
+interface BuildPayloadParams {
   message: string
   workflowId?: string
   workflowName?: string
@@ -60,16 +61,22 @@ export async function buildIntegrationToolSchemas(
       const subscriptionState = await getUserSubscriptionState(userId)
       shouldAppendEmailTagline = subscriptionState.isFree
     } catch (error) {
-      reqLogger.warn('Failed to load subscription state for copilot tool descriptions', {
-        userId,
-        error: error instanceof Error ? error.message : String(error),
-      })
+      logger.warn(
+        messageId
+          ? `Failed to load subscription state for copilot tool descriptions [messageId:${messageId}]`
+          : 'Failed to load subscription state for copilot tool descriptions',
+        {
+          userId,
+          error: error instanceof Error ? error.message : String(error),
+        }
+      )
     }
 
     for (const [toolId, toolConfig] of Object.entries(latestTools)) {
       try {
         const userSchema = createUserToolSchema(toolConfig)
         const strippedName = stripVersionSuffix(toolId)
+        const catalogEntry = getToolEntry(strippedName)
         integrationTools.push({
           name: strippedName,
           description: getCopilotToolDescription(toolConfig, {
@@ -79,6 +86,8 @@ export async function buildIntegrationToolSchemas(
           }),
           input_schema: userSchema as unknown as Record<string, unknown>,
           defer_loading: true,
+          executeLocally:
+            catalogEntry?.clientExecutable === true || catalogEntry?.executor === 'client',
           ...(toolConfig.oauth?.required && {
             oauth: {
               required: true,
@@ -87,16 +96,26 @@ export async function buildIntegrationToolSchemas(
           }),
         })
       } catch (toolError) {
-        reqLogger.warn('Failed to build schema for tool, skipping', {
-          toolId,
-          error: toolError instanceof Error ? toolError.message : String(toolError),
-        })
+        logger.warn(
+          messageId
+            ? `Failed to build schema for tool, skipping [messageId:${messageId}]`
+            : 'Failed to build schema for tool, skipping',
+          {
+            toolId,
+            error: toolError instanceof Error ? toolError.message : String(toolError),
+          }
+        )
       }
     }
   } catch (error) {
-    reqLogger.warn('Failed to build tool schemas', {
-      error: error instanceof Error ? error.message : String(error),
-    })
+    logger.warn(
+      messageId
+        ? `Failed to build tool schemas [messageId:${messageId}]`
+        : 'Failed to build tool schemas',
+      {
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
   }
   return integrationTools
 }
@@ -192,16 +211,27 @@ export async function buildCopilotRequestPayload(
               description:
                 mcpTool.description || `MCP tool: ${mcpTool.name} (${mcpTool.serverName})`,
               input_schema: mcpTool.inputSchema as unknown as Record<string, unknown>,
+              executeLocally: false,
             })
           }
           if (mcpTools.length > 0) {
-            payloadLogger.info('Added MCP tools to copilot payload', { count: mcpTools.length })
+            logger.error(
+              userMessageId
+                ? `Added MCP tools to copilot payload [messageId:${userMessageId}]`
+                : 'Added MCP tools to copilot payload',
+              { count: mcpTools.length }
+            )
           }
         }
       } catch (error) {
-        payloadLogger.warn('Failed to discover MCP tools for copilot', {
-          error: error instanceof Error ? error.message : String(error),
-        })
+        logger.warn(
+          userMessageId
+            ? `Failed to discover MCP tools for copilot [messageId:${userMessageId}]`
+            : 'Failed to discover MCP tools for copilot',
+          {
+            error: error instanceof Error ? error.message : String(error),
+          }
+        )
       }
     }
   }
diff --git a/apps/sim/lib/copilot/chat/persisted-message.test.ts b/apps/sim/lib/copilot/chat/persisted-message.test.ts
new file mode 100644
index 00000000000..793bff1702b
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/persisted-message.test.ts
@@ -0,0 +1,122 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import {
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+  normalizeMessage,
+} from './persisted-message'
+
+describe('persisted-message', () => {
+  it('round-trips canonical tool blocks through normalizeMessage', () => {
+    const result: OrchestratorResult = {
+      success: true,
+      content: 'done',
+      requestId: 'req-1',
+      contentBlocks: [
+        {
+          type: 'tool_call',
+          timestamp: Date.now(),
+          calledBy: 'workflow',
+          toolCall: {
+            id: 'tool-1',
+            name: 'read',
+            status: 'success',
+            params: { path: 'foo.txt' },
+            result: { success: true, output: { ok: true } },
+          },
+        },
+      ],
+      toolCalls: [],
+    }
+
+    const persisted = buildPersistedAssistantMessage(result)
+    const normalized = normalizeMessage(persisted as unknown as Record<string, unknown>)
+
+    expect(normalized.contentBlocks).toEqual([
+      {
+        type: 'tool',
+        phase: 'call',
+        toolCall: {
+          id: 'tool-1',
+          name: 'read',
+          state: 'success',
+          params: { path: 'foo.txt' },
+          result: { success: true, output: { ok: true } },
+          calledBy: 'workflow',
+        },
+      },
+      {
+        type: 'text',
+        channel: 'assistant',
+        content: 'done',
+      },
+    ])
+  })
+
+  it('normalizes legacy tool_call and top-level toolCalls shapes', () => {
+    const normalized = normalizeMessage({
+      id: 'msg-1',
+      role: 'assistant',
+      content: 'hello',
+      timestamp: '2024-01-01T00:00:00.000Z',
+      contentBlocks: [
+        {
+          type: 'tool_call',
+          toolCall: {
+            id: 'tool-1',
+            name: 'read',
+            state: 'cancelled',
+            display: { text: 'Stopped by user' },
+          },
+        },
+      ],
+      toolCalls: [
+        {
+          id: 'tool-2',
+          name: 'glob',
+          status: 'success',
+          result: { matches: [] },
+        },
+      ],
+    })
+
+    expect(normalized.contentBlocks).toEqual([
+      {
+        type: 'tool',
+        phase: 'call',
+        toolCall: {
+          id: 'tool-1',
+          name: 'read',
+          state: 'cancelled',
+          display: { title: 'Stopped by user' },
+        },
+      },
+      {
+        type: 'text',
+        channel: 'assistant',
+        content: 'hello',
+      },
+    ])
+  })
+
+  it('builds normalized user messages with stripped optional empties', () => {
+    const msg = buildPersistedUserMessage({
+      id: 'user-1',
+      content: 'hello',
+      fileAttachments: [],
+      contexts: [],
+    })
+
+    expect(msg).toMatchObject({
+      id: 'user-1',
+      role: 'user',
+      content: 'hello',
+    })
+    expect(msg.fileAttachments).toBeUndefined()
+    expect(msg.contexts).toBeUndefined()
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/persisted-message.ts b/apps/sim/lib/copilot/chat/persisted-message.ts
new file mode 100644
index 00000000000..012af71f1b3
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/persisted-message.ts
@@ -0,0 +1,475 @@
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1SpanPayloadKind,
+  type MothershipStreamV1StreamScope,
+  MothershipStreamV1TextChannel,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type {
+  ContentBlock,
+  LocalToolCallStatus,
+  OrchestratorResult,
+} from '@/lib/copilot/request/types'
+
+export type PersistedToolState = LocalToolCallStatus | MothershipStreamV1ToolOutcome
+
+export interface PersistedToolCall {
+  id: string
+  name: string
+  state: PersistedToolState
+  params?: Record<string, unknown>
+  result?: { success: boolean; output?: unknown; error?: string }
+  error?: string
+  calledBy?: string
+  durationMs?: number
+  display?: { title?: string; phaseLabel?: string }
+}
+
+export interface PersistedContentBlock {
+  type: MothershipStreamV1EventType
+  lane?: MothershipStreamV1StreamScope['lane']
+  channel?: MothershipStreamV1TextChannel
+  phase?: MothershipStreamV1ToolPhase
+  kind?: MothershipStreamV1SpanPayloadKind
+  lifecycle?: MothershipStreamV1SpanLifecycleEvent
+  status?: MothershipStreamV1CompletionStatus
+  content?: string
+  toolCall?: PersistedToolCall
+}
+
+export interface PersistedFileAttachment {
+  id: string
+  key: string
+  filename: string
+  media_type: string
+  size: number
+}
+
+export interface PersistedMessageContext {
+  kind: string
+  label: string
+  workflowId?: string
+  knowledgeId?: string
+  tableId?: string
+  fileId?: string
+  folderId?: string
+  chatId?: string
+}
+
+export interface PersistedMessage {
+  id: string
+  role: 'user' | 'assistant'
+  content: string
+  timestamp: string
+  requestId?: string
+  contentBlocks?: PersistedContentBlock[]
+  fileAttachments?: PersistedFileAttachment[]
+  contexts?: PersistedMessageContext[]
+}
+
+// ---------------------------------------------------------------------------
+// Write: OrchestratorResult → PersistedMessage
+// ---------------------------------------------------------------------------
+
+function resolveToolState(block: ContentBlock): PersistedToolState {
+  const tc = block.toolCall
+  if (!tc) return 'pending'
+  if (tc.result?.success !== undefined) {
+    return tc.result.success
+      ? MothershipStreamV1ToolOutcome.success
+      : MothershipStreamV1ToolOutcome.error
+  }
+  return tc.status as PersistedToolState
+}
+
+function mapContentBlock(block: ContentBlock): PersistedContentBlock {
+  switch (block.type) {
+    case 'text':
+      return {
+        type: MothershipStreamV1EventType.text,
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: block.content,
+      }
+    case 'thinking':
+      return {
+        type: MothershipStreamV1EventType.text,
+        channel: MothershipStreamV1TextChannel.thinking,
+        content: block.content,
+      }
+    case 'subagent':
+      return {
+        type: MothershipStreamV1EventType.span,
+        kind: MothershipStreamV1SpanPayloadKind.subagent,
+        lifecycle: MothershipStreamV1SpanLifecycleEvent.start,
+        content: block.content,
+      }
+    case 'subagent_text':
+      return {
+        type: MothershipStreamV1EventType.text,
+        lane: 'subagent',
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: block.content,
+      }
+    case 'tool_call': {
+      if (!block.toolCall) {
+        return {
+          type: MothershipStreamV1EventType.tool,
+          phase: MothershipStreamV1ToolPhase.call,
+          content: block.content,
+        }
+      }
+      const state = resolveToolState(block)
+      const isSubagentTool = !!block.calledBy
+      const isNonTerminal =
+        state === MothershipStreamV1ToolOutcome.cancelled ||
+        state === 'pending' ||
+        state === 'executing'
+
+      const toolCall: PersistedToolCall = {
+        id: block.toolCall.id,
+        name: block.toolCall.name,
+        state,
+        ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
+        ...(isSubagentTool && isNonTerminal
+          ? {}
+          : block.toolCall.params
+            ? { params: block.toolCall.params }
+            : {}),
+        ...(block.calledBy ? { calledBy: block.calledBy } : {}),
+      }
+
+      return {
+        type: MothershipStreamV1EventType.tool,
+        phase: MothershipStreamV1ToolPhase.call,
+        toolCall,
+      }
+    }
+    default:
+      return { type: MothershipStreamV1EventType.text, content: block.content }
+  }
+}
+
+export function buildPersistedAssistantMessage(
+  result: OrchestratorResult,
+  requestId?: string
+): PersistedMessage {
+  const message: PersistedMessage = {
+    id: crypto.randomUUID(),
+    role: 'assistant',
+    content: result.content,
+    timestamp: new Date().toISOString(),
+  }
+
+  if (requestId || result.requestId) {
+    message.requestId = requestId || result.requestId
+  }
+
+  if (result.contentBlocks.length > 0) {
+    message.contentBlocks = result.contentBlocks.map(mapContentBlock)
+  }
+
+  return message
+}
+
+export interface UserMessageParams {
+  id: string
+  content: string
+  fileAttachments?: PersistedFileAttachment[]
+  contexts?: PersistedMessageContext[]
+}
+
+export function buildPersistedUserMessage(params: UserMessageParams): PersistedMessage {
+  const message: PersistedMessage = {
+    id: params.id,
+    role: 'user',
+    content: params.content,
+    timestamp: new Date().toISOString(),
+  }
+
+  if (params.fileAttachments && params.fileAttachments.length > 0) {
+    message.fileAttachments = params.fileAttachments
+  }
+
+  if (params.contexts && params.contexts.length > 0) {
+    message.contexts = params.contexts.map((c) => ({
+      kind: c.kind,
+      label: c.label,
+      ...(c.workflowId ? { workflowId: c.workflowId } : {}),
+      ...(c.knowledgeId ? { knowledgeId: c.knowledgeId } : {}),
+      ...(c.tableId ? { tableId: c.tableId } : {}),
+      ...(c.fileId ? { fileId: c.fileId } : {}),
+      ...(c.folderId ? { folderId: c.folderId } : {}),
+      ...(c.chatId ? { chatId: c.chatId } : {}),
+    }))
+  }
+
+  return message
+}
+
+// ---------------------------------------------------------------------------
+// Read: raw JSONB → PersistedMessage
+// Handles both canonical (type: 'tool', 'text', 'span', 'complete') and
+// legacy (type: 'tool_call', 'thinking', 'subagent', 'stopped') blocks.
+// ---------------------------------------------------------------------------
+
+const CANONICAL_BLOCK_TYPES: Set<string> = new Set(Object.values(MothershipStreamV1EventType))
+
+interface RawBlock {
+  type: string
+  lane?: string
+  content?: string
+  channel?: string
+  phase?: string
+  kind?: string
+  lifecycle?: string
+  status?: string
+  toolCall?: {
+    id?: string
+    name?: string
+    state?: string
+    params?: Record<string, unknown>
+    result?: { success: boolean; output?: unknown; error?: string }
+    display?: { text?: string; title?: string; phaseLabel?: string }
+    calledBy?: string
+    durationMs?: number
+    error?: string
+  } | null
+}
+
+interface LegacyToolCall {
+  id: string
+  name: string
+  status: string
+  params?: Record<string, unknown>
+  result?: unknown
+  error?: string
+  durationMs?: number
+}
+
+const OUTCOME_NORMALIZATION: Record<string, PersistedToolState> = {
+  [MothershipStreamV1ToolOutcome.success]: MothershipStreamV1ToolOutcome.success,
+  [MothershipStreamV1ToolOutcome.error]: MothershipStreamV1ToolOutcome.error,
+  [MothershipStreamV1ToolOutcome.cancelled]: MothershipStreamV1ToolOutcome.cancelled,
+  [MothershipStreamV1ToolOutcome.skipped]: MothershipStreamV1ToolOutcome.skipped,
+  [MothershipStreamV1ToolOutcome.rejected]: MothershipStreamV1ToolOutcome.rejected,
+  pending: 'pending',
+  executing: 'executing',
+}
+
+function normalizeToolState(state: string | undefined): PersistedToolState {
+  if (!state) return 'pending'
+  return OUTCOME_NORMALIZATION[state] ?? MothershipStreamV1ToolOutcome.error
+}
+
+function isCanonicalBlock(block: RawBlock): boolean {
+  return CANONICAL_BLOCK_TYPES.has(block.type)
+}
+
+function normalizeCanonicalBlock(block: RawBlock): PersistedContentBlock {
+  const result: PersistedContentBlock = {
+    type: block.type as MothershipStreamV1EventType,
+  }
+  if (block.lane === 'main' || block.lane === 'subagent') {
+    result.lane = block.lane
+  }
+  if (block.content !== undefined) result.content = block.content
+  if (block.channel) result.channel = block.channel as MothershipStreamV1TextChannel
+  if (block.phase) result.phase = block.phase as MothershipStreamV1ToolPhase
+  if (block.kind) result.kind = block.kind as MothershipStreamV1SpanPayloadKind
+  if (block.lifecycle) result.lifecycle = block.lifecycle as MothershipStreamV1SpanLifecycleEvent
+  if (block.status) result.status = block.status as MothershipStreamV1CompletionStatus
+  if (block.toolCall) {
+    result.toolCall = {
+      id: block.toolCall.id ?? '',
+      name: block.toolCall.name ?? '',
+      state: normalizeToolState(block.toolCall.state),
+      ...(block.toolCall.params ? { params: block.toolCall.params } : {}),
+      ...(block.toolCall.result ? { result: block.toolCall.result } : {}),
+      ...(block.toolCall.calledBy ? { calledBy: block.toolCall.calledBy } : {}),
+      ...(block.toolCall.error ? { error: block.toolCall.error } : {}),
+      ...(block.toolCall.durationMs ? { durationMs: block.toolCall.durationMs } : {}),
+      ...(block.toolCall.display
+        ? {
+            display: {
+              title: block.toolCall.display.title ?? block.toolCall.display.text,
+              phaseLabel: block.toolCall.display.phaseLabel,
+            },
+          }
+        : {}),
+    }
+  }
+  return result
+}
+
+function normalizeLegacyBlock(block: RawBlock): PersistedContentBlock {
+  if (block.type === 'tool_call' && block.toolCall) {
+    return {
+      type: MothershipStreamV1EventType.tool,
+      phase: MothershipStreamV1ToolPhase.call,
+      toolCall: {
+        id: block.toolCall.id ?? '',
+        name: block.toolCall.name ?? '',
+        state: normalizeToolState(block.toolCall.state),
+        ...(block.toolCall.params ? { params: block.toolCall.params } : {}),
+        ...(block.toolCall.result ? { result: block.toolCall.result } : {}),
+        ...(block.toolCall.calledBy ? { calledBy: block.toolCall.calledBy } : {}),
+        ...(block.toolCall.display ? { display: { title: block.toolCall.display.text } } : {}),
+      },
+    }
+  }
+
+  if (block.type === 'thinking') {
+    return {
+      type: MothershipStreamV1EventType.text,
+      channel: MothershipStreamV1TextChannel.thinking,
+      content: block.content,
+    }
+  }
+
+  if (block.type === 'subagent' || block.type === 'subagent_text') {
+    if (block.type === 'subagent_text') {
+      return {
+        type: MothershipStreamV1EventType.text,
+        lane: 'subagent',
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: block.content,
+      }
+    }
+    return {
+      type: MothershipStreamV1EventType.span,
+      kind: MothershipStreamV1SpanPayloadKind.subagent,
+      lifecycle: MothershipStreamV1SpanLifecycleEvent.start,
+      content: block.content,
+    }
+  }
+
+  if (block.type === 'subagent_end') {
+    return {
+      type: MothershipStreamV1EventType.span,
+      kind: MothershipStreamV1SpanPayloadKind.subagent,
+      lifecycle: MothershipStreamV1SpanLifecycleEvent.end,
+    }
+  }
+
+  if (block.type === 'stopped') {
+    return {
+      type: MothershipStreamV1EventType.complete,
+      status: MothershipStreamV1CompletionStatus.cancelled,
+    }
+  }
+
+  return {
+    type: MothershipStreamV1EventType.text,
+    channel: MothershipStreamV1TextChannel.assistant,
+    content: block.content,
+  }
+}
+
+function normalizeBlock(block: RawBlock): PersistedContentBlock {
+  return isCanonicalBlock(block) ? normalizeCanonicalBlock(block) : normalizeLegacyBlock(block)
+}
+
+function normalizeLegacyToolCall(tc: LegacyToolCall): PersistedContentBlock {
+  const state = normalizeToolState(tc.status)
+  return {
+    type: MothershipStreamV1EventType.tool,
+    phase: MothershipStreamV1ToolPhase.call,
+    toolCall: {
+      id: tc.id,
+      name: tc.name,
+      state,
+      ...(tc.params ? { params: tc.params } : {}),
+      ...(tc.result != null
+        ? {
+            result: {
+              success: tc.status === MothershipStreamV1ToolOutcome.success,
+              output: tc.result,
+              ...(tc.error ? { error: tc.error } : {}),
+            },
+          }
+        : {}),
+      ...(tc.durationMs ? { durationMs: tc.durationMs } : {}),
+    },
+  }
+}
+
+function blocksContainTools(blocks: RawBlock[]): boolean {
+  return blocks.some((b) => b.type === 'tool_call' || b.type === MothershipStreamV1EventType.tool)
+}
+
+function normalizeBlocks(rawBlocks: RawBlock[], messageContent: string): PersistedContentBlock[] {
+  const blocks = rawBlocks.map(normalizeBlock)
+  const hasAssistantText = blocks.some(
+    (b) =>
+      b.type === MothershipStreamV1EventType.text &&
+      b.channel !== MothershipStreamV1TextChannel.thinking &&
+      b.content?.trim()
+  )
+  if (!hasAssistantText && messageContent.trim()) {
+    blocks.push({
+      type: MothershipStreamV1EventType.text,
+      channel: MothershipStreamV1TextChannel.assistant,
+      content: messageContent,
+    })
+  }
+  return blocks
+}
+
+export function normalizeMessage(raw: Record<string, unknown>): PersistedMessage {
+  const msg: PersistedMessage = {
+    id: (raw.id as string) ?? crypto.randomUUID(),
+    role: (raw.role as 'user' | 'assistant') ?? 'assistant',
+    content: (raw.content as string) ?? '',
+    timestamp: (raw.timestamp as string) ?? new Date().toISOString(),
+  }
+
+  if (raw.requestId && typeof raw.requestId === 'string') {
+    msg.requestId = raw.requestId
+  }
+
+  const rawBlocks = raw.contentBlocks as RawBlock[] | undefined
+  const rawToolCalls = raw.toolCalls as LegacyToolCall[] | undefined
+  const hasBlocks = Array.isArray(rawBlocks) && rawBlocks.length > 0
+  const hasToolCalls = Array.isArray(rawToolCalls) && rawToolCalls.length > 0
+
+  if (hasBlocks) {
+    msg.contentBlocks = normalizeBlocks(rawBlocks!, msg.content)
+    const contentBlocksAlreadyContainTools = blocksContainTools(rawBlocks!)
+    if (hasToolCalls && !contentBlocksAlreadyContainTools) {
+      msg.contentBlocks.push(...rawToolCalls!.map(normalizeLegacyToolCall))
+    }
+  } else if (hasToolCalls) {
+    msg.contentBlocks = rawToolCalls!.map(normalizeLegacyToolCall)
+    if (msg.content.trim()) {
+      msg.contentBlocks.push({
+        type: MothershipStreamV1EventType.text,
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: msg.content,
+      })
+    }
+  }
+
+  const rawAttachments = raw.fileAttachments as PersistedFileAttachment[] | undefined
+  if (Array.isArray(rawAttachments) && rawAttachments.length > 0) {
+    msg.fileAttachments = rawAttachments
+  }
+
+  const rawContexts = raw.contexts as PersistedMessageContext[] | undefined
+  if (Array.isArray(rawContexts) && rawContexts.length > 0) {
+    msg.contexts = rawContexts.map((c) => ({
+      kind: c.kind,
+      label: c.label,
+      ...(c.workflowId ? { workflowId: c.workflowId } : {}),
+      ...(c.knowledgeId ? { knowledgeId: c.knowledgeId } : {}),
+      ...(c.tableId ? { tableId: c.tableId } : {}),
+      ...(c.fileId ? { fileId: c.fileId } : {}),
+      ...(c.folderId ? { folderId: c.folderId } : {}),
+      ...(c.chatId ? { chatId: c.chatId } : {}),
+    }))
+  }
+
+  return msg
+}
diff --git a/apps/sim/lib/copilot/process-contents.ts b/apps/sim/lib/copilot/chat/process-contents.ts
similarity index 92%
rename from apps/sim/lib/copilot/process-contents.ts
rename to apps/sim/lib/copilot/chat/process-contents.ts
index 9673a124aeb..9319913a040 100644
--- a/apps/sim/lib/copilot/process-contents.ts
+++ b/apps/sim/lib/copilot/chat/process-contents.ts
@@ -19,9 +19,9 @@ import { checkKnowledgeBaseAccess } from '@/app/api/knowledge/utils'
 import { isHiddenFromDisplay } from '@/blocks/types'
 import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
 import { escapeRegExp } from '@/executor/constants'
-import type { ChatContext } from '@/stores/panel/copilot/types'
+import type { ChatContext } from '@/stores/panel'
 
-export type AgentContextType =
+type AgentContextType =
   | 'past_chat'
   | 'workflow'
   | 'current_workflow'
@@ -36,7 +36,7 @@ export type AgentContextType =
   | 'folder'
   | 'active_resource'
 
-export interface AgentContext {
+interface AgentContext {
   type: AgentContextType
   tag: string
   content: string
@@ -44,62 +44,6 @@ export interface AgentContext {
 
 const logger = createLogger('ProcessContents')
 
-export async function processContexts(
-  contexts: ChatContext[] | undefined
-): Promise<AgentContext[]> {
-  if (!Array.isArray(contexts) || contexts.length === 0) return []
-  const tasks = contexts.map(async (ctx) => {
-    try {
-      if (ctx.kind === 'past_chat') {
-        return await processPastChatViaApi(ctx.chatId, ctx.label ? `@${ctx.label}` : '@')
-      }
-      if ((ctx.kind === 'workflow' || ctx.kind === 'current_workflow') && ctx.workflowId) {
-        return await processWorkflowFromDb(
-          ctx.workflowId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@',
-          ctx.kind
-        )
-      }
-      if (ctx.kind === 'knowledge' && ctx.knowledgeId) {
-        return await processKnowledgeFromDb(
-          ctx.knowledgeId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@'
-        )
-      }
-      if (ctx.kind === 'blocks' && ctx.blockIds?.length > 0) {
-        return await processBlockMetadata(ctx.blockIds[0], ctx.label ? `@${ctx.label}` : '@')
-      }
-      if (ctx.kind === 'templates' && ctx.templateId) {
-        return await processTemplateFromDb(
-          ctx.templateId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@'
-        )
-      }
-      if (ctx.kind === 'logs' && ctx.executionId) {
-        return await processExecutionLogFromDb(
-          ctx.executionId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@'
-        )
-      }
-      if (ctx.kind === 'workflow_block' && ctx.workflowId && ctx.blockId) {
-        return await processWorkflowBlockFromDb(ctx.workflowId, undefined, ctx.blockId, ctx.label)
-      }
-      // Other kinds can be added here: workflow, blocks, logs, knowledge, templates, docs
-      return null
-    } catch (error) {
-      logger.error('Failed processing context', { ctx, error })
-      return null
-    }
-  })
-
-  const results = await Promise.all(tasks)
-  return results.filter((r): r is AgentContext => !!r) as AgentContext[]
-}
-
 // Server-side variant (recommended for use in API routes)
 export async function processContextsServer(
   contexts: ChatContext[] | undefined,
@@ -271,7 +215,7 @@ async function processPastChatFromDb(
   currentWorkspaceId?: string
 ): Promise<AgentContext | null> {
   try {
-    const { getAccessibleCopilotChat } = await import('@/lib/copilot/chat-lifecycle')
+    const { getAccessibleCopilotChat } = await import('./lifecycle')
     const chat = await getAccessibleCopilotChat(chatId, userId)
     if (!chat) {
       return null
diff --git a/apps/sim/lib/copilot/workspace-context.ts b/apps/sim/lib/copilot/chat/workspace-context.ts
similarity index 90%
rename from apps/sim/lib/copilot/workspace-context.ts
rename to apps/sim/lib/copilot/chat/workspace-context.ts
index ec8f1964ed3..86d77f808c4 100644
--- a/apps/sim/lib/copilot/workspace-context.ts
+++ b/apps/sim/lib/copilot/chat/workspace-context.ts
@@ -1,6 +1,5 @@
 import { db } from '@sim/db'
 import {
-  copilotChats,
   knowledgeBase,
   knowledgeConnector,
   mcpServers,
@@ -10,7 +9,7 @@ import {
   workflowSchedule,
 } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, count, desc, eq, inArray, isNull } from 'drizzle-orm'
+import { and, count, eq, inArray, isNull } from 'drizzle-orm'
 import { getAccessibleOAuthCredentials } from '@/lib/credentials/environment'
 import { listWorkspaceFiles } from '@/lib/uploads/contexts/workspace'
 import { listCustomTools } from '@/lib/workflows/custom-tools/operations'
@@ -46,6 +45,7 @@ export interface WorkspaceMdData {
     description?: string | null
     isDeployed: boolean
     lastRunAt?: Date | null
+    folderPath?: string | null
   }>
   knowledgeBases: Array<{
     id: string
@@ -56,7 +56,7 @@ export interface WorkspaceMdData {
   tables: Array<{ id: string; name: string; description?: string | null; rowCount: number }>
   files: Array<{ name: string; type: string; size: number }>
   credentials: Array<{ providerId: string }>
-  tasks: Array<{ id: string; title: string; updatedAt: Date }>
+  tasks?: Array<{ id: string; title: string; updatedAt: Date }>
   customTools?: Array<{ id: string; name: string }>
   mcpServers?: Array<{ id: string; name: string; url?: string | null; enabled: boolean }>
   skills?: Array<{ id: string; name: string; description: string }>
@@ -93,15 +93,40 @@ export function buildWorkspaceMd(data: WorkspaceMdData): string {
   }
 
   if (data.workflows.length > 0) {
-    const lines = data.workflows.map((wf) => {
-      const parts = [`- **${wf.name}** (${wf.id})`]
-      if (wf.description) parts.push(`  ${wf.description}`)
+    const rootWorkflows: typeof data.workflows = []
+    const folderWorkflows = new Map<string, typeof data.workflows>()
+
+    for (const wf of data.workflows) {
+      if (wf.folderPath) {
+        const existing = folderWorkflows.get(wf.folderPath) ?? []
+        existing.push(wf)
+        folderWorkflows.set(wf.folderPath, existing)
+      } else {
+        rootWorkflows.push(wf)
+      }
+    }
+
+    const formatWf = (wf: (typeof data.workflows)[0], indent: string) => {
+      const parts = [`${indent}- **${wf.name}** (${wf.id})`]
+      if (wf.description) parts.push(`${indent}  ${wf.description}`)
       const flags: string[] = []
       if (wf.isDeployed) flags.push('deployed')
       if (wf.lastRunAt) flags.push(`last run: ${wf.lastRunAt.toISOString().split('T')[0]}`)
       if (flags.length > 0) parts[0] += ` — ${flags.join(', ')}`
       return parts.join('\n')
-    })
+    }
+
+    const lines: string[] = []
+    for (const wf of rootWorkflows) {
+      lines.push(formatWf(wf, ''))
+    }
+    const sortedFolders = [...folderWorkflows.entries()].sort((a, b) => a[0].localeCompare(b[0]))
+    for (const [folder, wfs] of sortedFolders) {
+      lines.push(`- 📁 **${folder}/**`)
+      for (const wf of wfs) {
+        lines.push(formatWf(wf, '  '))
+      }
+    }
     sections.push(`## Workflows (${data.workflows.length})\n${lines.join('\n')}`)
   } else {
     sections.push('## Workflows (0)\n(none)')
@@ -182,14 +207,6 @@ export function buildWorkspaceMd(data: WorkspaceMdData): string {
     sections.push(`## Jobs (${data.jobs.length})\n${lines.join('\n')}`)
   }
 
-  if (data.tasks.length > 0) {
-    const lines = data.tasks.map((t) => {
-      const date = t.updatedAt.toISOString().split('T')[0]
-      return `- **${t.title || 'Untitled'}** (${t.id}) — ${date}`
-    })
-    sections.push(`## Recent Tasks (${data.tasks.length})\n${lines.join('\n')}`)
-  }
-
   return sections.join('\n\n')
 }
 
@@ -216,7 +233,6 @@ export async function generateWorkspaceContext(
       tables,
       files,
       credentials,
-      recentTasks,
       customTools,
       mcpServerRows,
       skillRows,
@@ -262,23 +278,6 @@ export async function generateWorkspaceContext(
 
       getAccessibleOAuthCredentials(workspaceId, userId),
 
-      db
-        .select({
-          id: copilotChats.id,
-          title: copilotChats.title,
-          updatedAt: copilotChats.updatedAt,
-        })
-        .from(copilotChats)
-        .where(
-          and(
-            eq(copilotChats.workspaceId, workspaceId),
-            eq(copilotChats.userId, userId),
-            eq(copilotChats.type, 'mothership')
-          )
-        )
-        .orderBy(desc(copilotChats.updatedAt))
-        .limit(5),
-
       listCustomTools({ userId, workspaceId }),
 
       db
@@ -363,11 +362,6 @@ export async function generateWorkspaceContext(
       tables: tables.map((t, i) => ({ ...t, rowCount: rowCounts[i] ?? 0 })),
       files: files.map((f) => ({ name: f.name, type: f.type, size: f.size })),
       credentials: credentials.map((c) => ({ providerId: c.providerId })),
-      tasks: recentTasks.map((t) => ({
-        id: t.id,
-        title: t.title || 'Untitled',
-        updatedAt: t.updatedAt,
-      })),
       customTools: customTools.map((t) => ({ id: t.id, name: t.title })),
       mcpServers: mcpServerRows,
       skills: skillRows.map((s) => ({ id: s.id, name: s.name, description: s.description })),
diff --git a/apps/sim/lib/copilot/client-sse/types.ts b/apps/sim/lib/copilot/client-sse/types.ts
deleted file mode 100644
index 128ec75d872..00000000000
--- a/apps/sim/lib/copilot/client-sse/types.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type {
-  ChatContext,
-  CopilotToolCall,
-  SubAgentContentBlock,
-} from '@/stores/panel/copilot/types'
-
-/**
- * A content block used in copilot messages and during streaming.
- * Uses a literal type union for `type` to stay compatible with CopilotMessage.
- */
-export type ContentBlockType = 'text' | 'thinking' | 'tool_call' | 'contexts'
-
-export interface ClientContentBlock {
-  type: ContentBlockType
-  content?: string
-  timestamp: number
-  toolCall?: CopilotToolCall | null
-  startTime?: number
-  duration?: number
-  contexts?: ChatContext[]
-}
-
-export interface StreamingContext {
-  messageId: string
-  requestId?: string
-  accumulatedContent: string
-  contentBlocks: ClientContentBlock[]
-  currentTextBlock: ClientContentBlock | null
-  isInThinkingBlock: boolean
-  currentThinkingBlock: ClientContentBlock | null
-  isInDesignWorkflowBlock: boolean
-  designWorkflowContent: string
-  pendingContent: string
-  newChatId?: string
-  doneEventCount: number
-  streamComplete?: boolean
-  wasAborted?: boolean
-  suppressContinueOption?: boolean
-  subAgentParentToolCallId?: string
-  subAgentParentStack: string[]
-  subAgentContent: Record<string, string>
-  subAgentToolCalls: Record<string, CopilotToolCall[]>
-  subAgentBlocks: Record<string, SubAgentContentBlock[]>
-  suppressStreamingUpdates?: boolean
-  activeCompactionId?: string
-}
-
-export type ClientStreamingContext = StreamingContext
diff --git a/apps/sim/lib/copilot/constants.ts b/apps/sim/lib/copilot/constants.ts
index fbf4e312957..d0d10f452c7 100644
--- a/apps/sim/lib/copilot/constants.ts
+++ b/apps/sim/lib/copilot/constants.ts
@@ -10,13 +10,6 @@ export const SIM_AGENT_API_URL =
     ? rawAgentUrl
     : SIM_AGENT_API_URL_DEFAULT
 
-// ---------------------------------------------------------------------------
-// Redis key prefixes
-// ---------------------------------------------------------------------------
-
-/** Redis key prefix for copilot SSE stream buffers. */
-export const REDIS_COPILOT_STREAM_PREFIX = 'copilot_stream:'
-
 // ---------------------------------------------------------------------------
 // Timeouts
 // ---------------------------------------------------------------------------
@@ -31,29 +24,9 @@ export const STREAM_TIMEOUT_MS = 3_600_000
 // Stream resume
 // ---------------------------------------------------------------------------
 
-/** Maximum number of resume attempts before giving up. */
-export const MAX_RESUME_ATTEMPTS = 3
-
 /** SessionStorage key for persisting active stream metadata across page reloads. */
 export const STREAM_STORAGE_KEY = 'copilot_active_stream'
 
-// ---------------------------------------------------------------------------
-// Client-side streaming batching
-// ---------------------------------------------------------------------------
-
-/** Delay (ms) before processing the next queued message after stream completion. */
-export const QUEUE_PROCESS_DELAY_MS = 100
-
-/** Delay (ms) before invalidating subscription queries after stream completion. */
-export const SUBSCRIPTION_INVALIDATE_DELAY_MS = 1_000
-
-// ---------------------------------------------------------------------------
-// UI helpers
-// ---------------------------------------------------------------------------
-
-/** Maximum character length for an optimistic chat title derived from a user message. */
-export const OPTIMISTIC_TITLE_MAX_LENGTH = 50
-
 // ---------------------------------------------------------------------------
 // Copilot API paths (client-side fetch targets)
 // ---------------------------------------------------------------------------
@@ -64,39 +37,37 @@ export const COPILOT_CHAT_API_PATH = '/api/copilot/chat'
 /** POST — send a workspace-scoped chat message (mothership). */
 export const MOTHERSHIP_CHAT_API_PATH = '/api/mothership/chat'
 
-/** GET — resume/replay a copilot SSE stream. */
-export const COPILOT_CHAT_STREAM_API_PATH = '/api/copilot/chat/stream'
-
-/** POST — persist chat messages / plan artifact / config. */
-export const COPILOT_UPDATE_MESSAGES_API_PATH = '/api/copilot/chat/update-messages'
-
-/** DELETE — delete a copilot chat. */
-export const COPILOT_DELETE_CHAT_API_PATH = '/api/copilot/chat/delete'
-
 /** POST — confirm or reject a tool call. */
 export const COPILOT_CONFIRM_API_PATH = '/api/copilot/confirm'
 
 /** POST — forward diff-accepted/rejected stats to the copilot backend. */
 export const COPILOT_STATS_API_PATH = '/api/copilot/stats'
 
-/** GET — load checkpoints for a chat. */
-export const COPILOT_CHECKPOINTS_API_PATH = '/api/copilot/checkpoints'
+// ---------------------------------------------------------------------------
+// Dedup limits
+// ---------------------------------------------------------------------------
+
+/** Maximum entries in the in-memory SSE tool-event dedup cache. */
+export const STREAM_BUFFER_MAX_DEDUP_ENTRIES = 1_000
 
-/** POST — revert to a checkpoint. */
-export const COPILOT_CHECKPOINTS_REVERT_API_PATH = '/api/copilot/checkpoints/revert'
+// ---------------------------------------------------------------------------
+// Tool result size limits
+// ---------------------------------------------------------------------------
 
-/** GET/POST/DELETE — manage auto-allowed tools. */
-export const COPILOT_AUTO_ALLOWED_TOOLS_API_PATH = '/api/copilot/auto-allowed-tools'
+/** Approximate max inline tool-result budget before artifact/error handling takes over. */
+export const TOOL_RESULT_MAX_INLINE_TOKENS = 50_000
 
-/** GET — fetch dynamically available copilot models. */
-export const COPILOT_MODELS_API_PATH = '/api/copilot/models'
+/** Rough chars-per-token estimate used when only serialized text length is available. */
+export const TOOL_RESULT_ESTIMATED_CHARS_PER_TOKEN = 4
 
-/** GET — fetch user credentials for masking. */
-export const COPILOT_CREDENTIALS_API_PATH = '/api/copilot/credentials'
+/** Approximate max inline tool-result size in characters. */
+export const TOOL_RESULT_MAX_INLINE_CHARS =
+  TOOL_RESULT_MAX_INLINE_TOKENS * TOOL_RESULT_ESTIMATED_CHARS_PER_TOKEN
 
 // ---------------------------------------------------------------------------
-// Dedup limits
+// Copilot modes
 // ---------------------------------------------------------------------------
 
-/** Maximum entries in the in-memory SSE tool-event dedup cache. */
-export const STREAM_BUFFER_MAX_DEDUP_ENTRIES = 1_000
+export const COPILOT_MODES = ['ask', 'build', 'plan'] as const
+
+export const COPILOT_REQUEST_MODES = ['ask', 'build', 'plan', 'agent'] as const
diff --git a/apps/sim/lib/copilot/generated/mothership-stream-v1.ts b/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
new file mode 100644
index 00000000000..ded9a6b4c3c
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
@@ -0,0 +1,295 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+//
+
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1EventType".
+ */
+export type MothershipStreamV1EventType =
+  | 'session'
+  | 'text'
+  | 'tool'
+  | 'span'
+  | 'resource'
+  | 'run'
+  | 'error'
+  | 'complete'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1AsyncToolRecordStatus".
+ */
+export type MothershipStreamV1AsyncToolRecordStatus =
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'delivered'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1CompletionStatus".
+ */
+export type MothershipStreamV1CompletionStatus = 'complete' | 'error' | 'cancelled'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ResourceOp".
+ */
+export type MothershipStreamV1ResourceOp = 'upsert' | 'remove'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1RunKind".
+ */
+export type MothershipStreamV1RunKind =
+  | 'checkpoint_pause'
+  | 'resumed'
+  | 'compaction_start'
+  | 'compaction_done'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1SessionKind".
+ */
+export type MothershipStreamV1SessionKind = 'trace' | 'chat' | 'title' | 'start'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1SpanKind".
+ */
+export type MothershipStreamV1SpanKind = 'subagent'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1SpanLifecycleEvent".
+ */
+export type MothershipStreamV1SpanLifecycleEvent = 'start' | 'end'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1SpanPayloadKind".
+ */
+export type MothershipStreamV1SpanPayloadKind = 'subagent' | 'structured_result' | 'subagent_result'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1TextChannel".
+ */
+export type MothershipStreamV1TextChannel = 'assistant' | 'thinking'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ToolExecutor".
+ */
+export type MothershipStreamV1ToolExecutor = 'go' | 'sim' | 'client'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ToolMode".
+ */
+export type MothershipStreamV1ToolMode = 'sync' | 'async'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ToolPhase".
+ */
+export type MothershipStreamV1ToolPhase = 'call' | 'args_delta' | 'result'
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ToolOutcome".
+ */
+export type MothershipStreamV1ToolOutcome =
+  | 'success'
+  | 'error'
+  | 'cancelled'
+  | 'skipped'
+  | 'rejected'
+
+/**
+ * Shared execution-oriented mothership stream contract from Go to Sim.
+ */
+export interface MothershipStreamV1EventEnvelope {
+  payload: MothershipStreamV1AdditionalPropertiesMap
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: MothershipStreamV1EventType
+  v: number
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1AdditionalPropertiesMap".
+ */
+export interface MothershipStreamV1AdditionalPropertiesMap {
+  [k: string]: unknown
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1StreamScope".
+ */
+export interface MothershipStreamV1StreamScope {
+  agentId?: string
+  lane: 'main' | 'subagent'
+  parentToolCallId?: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1StreamRef".
+ */
+export interface MothershipStreamV1StreamRef {
+  chatId?: string
+  cursor?: string
+  streamId: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1Trace".
+ */
+export interface MothershipStreamV1Trace {
+  requestId: string
+  spanId?: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1CheckpointPausePayload".
+ */
+export interface MothershipStreamV1CheckpointPausePayload {
+  checkpointId: string
+  executionId: string
+  pendingToolCallIds: string[]
+  runId: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ResumeRequest".
+ */
+export interface MothershipStreamV1ResumeRequest {
+  checkpointId: string
+  results: MothershipStreamV1ResumeToolResult[]
+  streamId: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ResumeToolResult".
+ */
+export interface MothershipStreamV1ResumeToolResult {
+  error?: string
+  output?: unknown
+  success: boolean
+  toolCallId: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1StreamCursor".
+ */
+export interface MothershipStreamV1StreamCursor {
+  cursor: string
+  seq: number
+  streamId: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ToolCallDescriptor".
+ */
+export interface MothershipStreamV1ToolCallDescriptor {
+  arguments?: MothershipStreamV1AdditionalPropertiesMap
+  argumentsDelta?: string
+  executor: MothershipStreamV1ToolExecutor
+  mode: MothershipStreamV1ToolMode
+  partial?: boolean
+  phase: MothershipStreamV1ToolPhase
+  requiresConfirmation?: boolean
+  toolCallId: string
+  toolName: string
+}
+/**
+ * This interface was referenced by `MothershipStreamV1EventEnvelope`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1ToolResultPayload".
+ */
+export interface MothershipStreamV1ToolResultPayload {
+  error?: string
+  output?: unknown
+  success: boolean
+}
+
+export const MothershipStreamV1AsyncToolRecordStatus = {
+  pending: 'pending',
+  running: 'running',
+  completed: 'completed',
+  failed: 'failed',
+  cancelled: 'cancelled',
+  delivered: 'delivered',
+} as const
+
+export const MothershipStreamV1CompletionStatus = {
+  complete: 'complete',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
+
+export const MothershipStreamV1EventType = {
+  session: 'session',
+  text: 'text',
+  tool: 'tool',
+  span: 'span',
+  resource: 'resource',
+  run: 'run',
+  error: 'error',
+  complete: 'complete',
+} as const
+
+export const MothershipStreamV1ResourceOp = {
+  upsert: 'upsert',
+  remove: 'remove',
+} as const
+
+export const MothershipStreamV1RunKind = {
+  checkpoint_pause: 'checkpoint_pause',
+  resumed: 'resumed',
+  compaction_start: 'compaction_start',
+  compaction_done: 'compaction_done',
+} as const
+
+export const MothershipStreamV1SessionKind = {
+  trace: 'trace',
+  chat: 'chat',
+  title: 'title',
+  start: 'start',
+} as const
+
+export const MothershipStreamV1SpanKind = {
+  subagent: 'subagent',
+} as const
+
+export const MothershipStreamV1SpanLifecycleEvent = {
+  start: 'start',
+  end: 'end',
+} as const
+
+export const MothershipStreamV1SpanPayloadKind = {
+  subagent: 'subagent',
+  structured_result: 'structured_result',
+  subagent_result: 'subagent_result',
+} as const
+
+export const MothershipStreamV1TextChannel = {
+  assistant: 'assistant',
+  thinking: 'thinking',
+} as const
+
+export const MothershipStreamV1ToolExecutor = {
+  go: 'go',
+  sim: 'sim',
+  client: 'client',
+} as const
+
+export const MothershipStreamV1ToolMode = {
+  sync: 'sync',
+  async: 'async',
+} as const
+
+export const MothershipStreamV1ToolOutcome = {
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+  skipped: 'skipped',
+  rejected: 'rejected',
+} as const
+
+export const MothershipStreamV1ToolPhase = {
+  call: 'call',
+  args_delta: 'args_delta',
+  result: 'result',
+} as const
diff --git a/apps/sim/lib/copilot/generated/request-trace-v1.ts b/apps/sim/lib/copilot/generated/request-trace-v1.ts
new file mode 100644
index 00000000000..309b49ad06a
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/request-trace-v1.ts
@@ -0,0 +1,132 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+//
+
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1Outcome".
+ */
+export type RequestTraceV1Outcome = 'success' | 'error' | 'cancelled'
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1SpanSource".
+ */
+export type RequestTraceV1SpanSource = 'sim' | 'go'
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1SpanStatus".
+ */
+export type RequestTraceV1SpanStatus = 'ok' | 'error' | 'cancelled'
+
+/**
+ * Trace report sent from Sim to Go after a request completes.
+ */
+export interface RequestTraceV1SimReport {
+  chatId?: string
+  cost?: RequestTraceV1CostSummary
+  durationMs: number
+  endMs: number
+  executionId?: string
+  goTraceId?: string
+  outcome: RequestTraceV1Outcome
+  runId?: string
+  simRequestId: string
+  spans: RequestTraceV1Span[]
+  startMs: number
+  streamId?: string
+  usage?: RequestTraceV1UsageSummary
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1CostSummary".
+ */
+export interface RequestTraceV1CostSummary {
+  billedTotalCost?: number
+  rawTotalCost?: number
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1Span".
+ */
+export interface RequestTraceV1Span {
+  attributes?: MothershipStreamV1AdditionalPropertiesMap
+  durationMs?: number
+  endMs?: number
+  kind?: string
+  name: string
+  parentName?: string
+  source?: RequestTraceV1SpanSource
+  startMs: number
+  status: RequestTraceV1SpanStatus
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1AdditionalPropertiesMap".
+ */
+export interface MothershipStreamV1AdditionalPropertiesMap {
+  [k: string]: unknown
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1UsageSummary".
+ */
+export interface RequestTraceV1UsageSummary {
+  cacheReadTokens?: number
+  cacheWriteTokens?: number
+  inputTokens?: number
+  outputTokens?: number
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1MergedTrace".
+ */
+export interface RequestTraceV1MergedTrace {
+  chatId?: string
+  cost?: RequestTraceV1CostSummary
+  durationMs: number
+  endMs: number
+  goTraceId: string
+  outcome: RequestTraceV1Outcome
+  serviceCharges?: MothershipStreamV1AdditionalPropertiesMap
+  simRequestId?: string
+  spans: RequestTraceV1Span[]
+  startMs: number
+  streamId?: string
+  usage?: RequestTraceV1UsageSummary
+  userId?: string
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1SimReport".
+ */
+export interface RequestTraceV1SimReport1 {
+  chatId?: string
+  cost?: RequestTraceV1CostSummary
+  durationMs: number
+  endMs: number
+  executionId?: string
+  goTraceId?: string
+  outcome: RequestTraceV1Outcome
+  runId?: string
+  simRequestId: string
+  spans: RequestTraceV1Span[]
+  startMs: number
+  streamId?: string
+  usage?: RequestTraceV1UsageSummary
+}
+
+export const RequestTraceV1Outcome = {
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
+
+export const RequestTraceV1SpanSource = {
+  sim: 'sim',
+  go: 'go',
+} as const
+
+export const RequestTraceV1SpanStatus = {
+  ok: 'ok',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
diff --git a/apps/sim/lib/copilot/generated/tool-catalog-v1.ts b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
new file mode 100644
index 00000000000..d2e503552f4
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
@@ -0,0 +1,2704 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+// Generated from copilot/contracts/tool-catalog-v1.json
+//
+
+export interface ToolCatalogEntry {
+  clientExecutable?: boolean
+  executor: 'client' | 'go' | 'sim' | 'subagent'
+  hidden?: boolean
+  id:
+    | 'agent'
+    | 'auth'
+    | 'check_deployment_status'
+    | 'complete_job'
+    | 'context_write'
+    | 'crawl_website'
+    | 'create_folder'
+    | 'create_job'
+    | 'create_workflow'
+    | 'create_workspace_mcp_server'
+    | 'debug'
+    | 'delete_folder'
+    | 'delete_workflow'
+    | 'delete_workspace_mcp_server'
+    | 'deploy'
+    | 'deploy_api'
+    | 'deploy_chat'
+    | 'deploy_mcp'
+    | 'download_to_workspace_file'
+    | 'edit_workflow'
+    | 'file'
+    | 'function_execute'
+    | 'generate_api_key'
+    | 'generate_image'
+    | 'generate_visualization'
+    | 'get_block_outputs'
+    | 'get_block_upstream_references'
+    | 'get_deployed_workflow_state'
+    | 'get_deployment_version'
+    | 'get_execution_summary'
+    | 'get_job_logs'
+    | 'get_page_contents'
+    | 'get_platform_actions'
+    | 'get_workflow_data'
+    | 'get_workflow_logs'
+    | 'glob'
+    | 'grep'
+    | 'job'
+    | 'knowledge'
+    | 'knowledge_base'
+    | 'list_folders'
+    | 'list_user_workspaces'
+    | 'list_workspace_mcp_servers'
+    | 'manage_credential'
+    | 'manage_custom_tool'
+    | 'manage_job'
+    | 'manage_mcp_tool'
+    | 'manage_skill'
+    | 'materialize_file'
+    | 'move_folder'
+    | 'move_workflow'
+    | 'oauth_get_auth_link'
+    | 'oauth_request_access'
+    | 'open_resource'
+    | 'read'
+    | 'redeploy'
+    | 'rename_workflow'
+    | 'research'
+    | 'respond'
+    | 'revert_to_version'
+    | 'run'
+    | 'run_block'
+    | 'run_from_block'
+    | 'run_workflow'
+    | 'run_workflow_until_block'
+    | 'scrape_page'
+    | 'search_documentation'
+    | 'search_library_docs'
+    | 'search_online'
+    | 'search_patterns'
+    | 'set_environment_variables'
+    | 'set_global_workflow_variables'
+    | 'superagent'
+    | 'table'
+    | 'tool_search_tool_regex'
+    | 'update_job_history'
+    | 'update_workspace_mcp_server'
+    | 'user_memory'
+    | 'user_table'
+    | 'workflow'
+    | 'workspace_file'
+  internal?: boolean
+  mode: 'async' | 'sync'
+  name:
+    | 'agent'
+    | 'auth'
+    | 'check_deployment_status'
+    | 'complete_job'
+    | 'context_write'
+    | 'crawl_website'
+    | 'create_folder'
+    | 'create_job'
+    | 'create_workflow'
+    | 'create_workspace_mcp_server'
+    | 'debug'
+    | 'delete_folder'
+    | 'delete_workflow'
+    | 'delete_workspace_mcp_server'
+    | 'deploy'
+    | 'deploy_api'
+    | 'deploy_chat'
+    | 'deploy_mcp'
+    | 'download_to_workspace_file'
+    | 'edit_workflow'
+    | 'file'
+    | 'function_execute'
+    | 'generate_api_key'
+    | 'generate_image'
+    | 'generate_visualization'
+    | 'get_block_outputs'
+    | 'get_block_upstream_references'
+    | 'get_deployed_workflow_state'
+    | 'get_deployment_version'
+    | 'get_execution_summary'
+    | 'get_job_logs'
+    | 'get_page_contents'
+    | 'get_platform_actions'
+    | 'get_workflow_data'
+    | 'get_workflow_logs'
+    | 'glob'
+    | 'grep'
+    | 'job'
+    | 'knowledge'
+    | 'knowledge_base'
+    | 'list_folders'
+    | 'list_user_workspaces'
+    | 'list_workspace_mcp_servers'
+    | 'manage_credential'
+    | 'manage_custom_tool'
+    | 'manage_job'
+    | 'manage_mcp_tool'
+    | 'manage_skill'
+    | 'materialize_file'
+    | 'move_folder'
+    | 'move_workflow'
+    | 'oauth_get_auth_link'
+    | 'oauth_request_access'
+    | 'open_resource'
+    | 'read'
+    | 'redeploy'
+    | 'rename_workflow'
+    | 'research'
+    | 'respond'
+    | 'revert_to_version'
+    | 'run'
+    | 'run_block'
+    | 'run_from_block'
+    | 'run_workflow'
+    | 'run_workflow_until_block'
+    | 'scrape_page'
+    | 'search_documentation'
+    | 'search_library_docs'
+    | 'search_online'
+    | 'search_patterns'
+    | 'set_environment_variables'
+    | 'set_global_workflow_variables'
+    | 'superagent'
+    | 'table'
+    | 'tool_search_tool_regex'
+    | 'update_job_history'
+    | 'update_workspace_mcp_server'
+    | 'user_memory'
+    | 'user_table'
+    | 'workflow'
+    | 'workspace_file'
+  parameters: unknown
+  requiredPermission?: 'admin' | 'write'
+  requiresConfirmation?: boolean
+  resultSchema?: unknown
+  subagentId?:
+    | 'agent'
+    | 'auth'
+    | 'debug'
+    | 'deploy'
+    | 'file'
+    | 'job'
+    | 'knowledge'
+    | 'research'
+    | 'run'
+    | 'superagent'
+    | 'table'
+    | 'workflow'
+}
+
+export const Agent: ToolCatalogEntry = {
+  id: 'agent',
+  name: 'agent',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What tool/skill/MCP action is needed.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'agent',
+  internal: true,
+  requiredPermission: 'write',
+}
+
+export const Auth: ToolCatalogEntry = {
+  id: 'auth',
+  name: 'auth',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What authentication/credential action is needed.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'auth',
+  internal: true,
+}
+
+export const CheckDeploymentStatus: ToolCatalogEntry = {
+  id: 'check_deployment_status',
+  name: 'check_deployment_status',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to check (defaults to current workflow)',
+      },
+    },
+  },
+}
+
+export const CompleteJob: ToolCatalogEntry = {
+  id: 'complete_job',
+  name: 'complete_job',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      jobId: { type: 'string', description: 'The ID of the job to mark as completed.' },
+    },
+    required: ['jobId'],
+  },
+}
+
+export const ContextWrite: ToolCatalogEntry = {
+  id: 'context_write',
+  name: 'context_write',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'Full content to write to the file (replaces existing content)',
+      },
+      file_path: { type: 'string', description: "Path of the file to write (e.g. 'SESSION.md')" },
+    },
+    required: ['file_path', 'content'],
+  },
+}
+
+export const CrawlWebsite: ToolCatalogEntry = {
+  id: 'crawl_website',
+  name: 'crawl_website',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      exclude_paths: {
+        type: 'array',
+        description: 'Skip URLs matching these patterns',
+        items: { type: 'string' },
+      },
+      include_paths: {
+        type: 'array',
+        description: 'Only crawl URLs matching these patterns',
+        items: { type: 'string' },
+      },
+      limit: { type: 'number', description: 'Maximum pages to crawl (default 10, max 50)' },
+      max_depth: { type: 'number', description: 'How deep to follow links (default 2)' },
+      url: { type: 'string', description: 'Starting URL to crawl from' },
+    },
+    required: ['url'],
+  },
+}
+
+export const CreateFolder: ToolCatalogEntry = {
+  id: 'create_folder',
+  name: 'create_folder',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Folder name.' },
+      parentId: { type: 'string', description: 'Optional parent folder ID.' },
+      workspaceId: { type: 'string', description: 'Optional workspace ID.' },
+    },
+    required: ['name'],
+  },
+  requiredPermission: 'write',
+}
+
+export const CreateJob: ToolCatalogEntry = {
+  id: 'create_job',
+  name: 'create_job',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      cron: {
+        type: 'string',
+        description:
+          "Cron expression for recurring jobs (e.g., '*/5 * * * *' for every 5 minutes, '0 9 * * *' for daily at 9 AM). Omit for one-time jobs.",
+      },
+      lifecycle: {
+        type: 'string',
+        description:
+          "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called after the success condition is met.",
+        enum: ['persistent', 'until_complete'],
+      },
+      maxRuns: {
+        type: 'integer',
+        description:
+          'Maximum number of executions before the job auto-completes. Safety limit to prevent runaway polling.',
+      },
+      prompt: {
+        type: 'string',
+        description:
+          'The prompt to execute when the job fires. This is sent to the Mothership as a user message.',
+      },
+      successCondition: {
+        type: 'string',
+        description:
+          "What must happen for the job to be considered complete. Used with until_complete lifecycle (e.g., 'John has replied to the partnership email').",
+      },
+      time: {
+        type: 'string',
+        description:
+          "ISO 8601 datetime for one-time execution or as the start time for a cron schedule (e.g., '2026-03-06T09:00:00'). Include timezone offset or use the timezone parameter.",
+      },
+      timezone: {
+        type: 'string',
+        description:
+          "IANA timezone for the schedule (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC.",
+      },
+      title: {
+        type: 'string',
+        description:
+          "A short, descriptive title for the job (e.g., 'Email Poller', 'Daily Report'). Used as the display name.",
+      },
+    },
+    required: ['title', 'prompt'],
+  },
+}
+
+export const CreateWorkflow: ToolCatalogEntry = {
+  id: 'create_workflow',
+  name: 'create_workflow',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      description: { type: 'string', description: 'Optional workflow description.' },
+      folderId: { type: 'string', description: 'Optional folder ID.' },
+      name: { type: 'string', description: 'Workflow name.' },
+      workspaceId: { type: 'string', description: 'Optional workspace ID.' },
+    },
+    required: ['name'],
+  },
+  requiredPermission: 'write',
+}
+
+export const CreateWorkspaceMcpServer: ToolCatalogEntry = {
+  id: 'create_workspace_mcp_server',
+  name: 'create_workspace_mcp_server',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      description: { type: 'string', description: 'Optional description for the server' },
+      name: { type: 'string', description: 'Required: server name' },
+      workspaceId: { type: 'string', description: 'Workspace ID (defaults to current workspace)' },
+    },
+    required: ['name'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const Debug: ToolCatalogEntry = {
+  id: 'debug',
+  name: 'debug',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      context: {
+        description:
+          'Pre-gathered context: workflow state JSON, block schemas, error logs. The debug agent will skip re-reading anything included here.',
+        type: 'string',
+      },
+      request: {
+        description:
+          'What to debug. Include error messages, block IDs, and any context about the failure.',
+        type: 'string',
+      },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'debug',
+  internal: true,
+}
+
+export const DeleteFolder: ToolCatalogEntry = {
+  id: 'delete_folder',
+  name: 'delete_folder',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: { folderId: { type: 'string', description: 'The folder ID to delete.' } },
+    required: ['folderId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const DeleteWorkflow: ToolCatalogEntry = {
+  id: 'delete_workflow',
+  name: 'delete_workflow',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: { workflowId: { type: 'string', description: 'The workflow ID to delete.' } },
+    required: ['workflowId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const DeleteWorkspaceMcpServer: ToolCatalogEntry = {
+  id: 'delete_workspace_mcp_server',
+  name: 'delete_workspace_mcp_server',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      serverId: { type: 'string', description: 'Required: the MCP server ID to delete' },
+    },
+    required: ['serverId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const Deploy: ToolCatalogEntry = {
+  id: 'deploy',
+  name: 'deploy',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: {
+        description:
+          'Detailed deployment instructions. Include deployment type (api/chat) and ALL user-specified options: identifier, title, description, authType, password, allowedEmails, welcomeMessage, outputConfigs (block outputs to display).',
+        type: 'string',
+      },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'deploy',
+  internal: true,
+}
+
+export const DeployApi: ToolCatalogEntry = {
+  id: 'deploy_api',
+  name: 'deploy_api',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Whether to deploy or undeploy the API endpoint',
+        enum: ['deploy', 'undeploy'],
+        default: 'deploy',
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to deploy (required in workspace context)',
+      },
+    },
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DeployChat: ToolCatalogEntry = {
+  id: 'deploy_chat',
+  name: 'deploy_chat',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Whether to deploy or undeploy the chat interface',
+        enum: ['deploy', 'undeploy'],
+        default: 'deploy',
+      },
+      allowedEmails: {
+        type: 'array',
+        description: 'List of allowed emails/domains for email or SSO auth',
+        items: { type: 'string' },
+      },
+      authType: {
+        type: 'string',
+        description: 'Authentication type: public, password, email, or sso',
+        enum: ['public', 'password', 'email', 'sso'],
+        default: 'public',
+      },
+      description: { type: 'string', description: 'Optional description for the chat' },
+      identifier: {
+        type: 'string',
+        description: 'URL slug for the chat (lowercase letters, numbers, hyphens only)',
+      },
+      outputConfigs: {
+        type: 'array',
+        description: 'Output configurations specifying which block outputs to display in chat',
+        items: {
+          type: 'object',
+          properties: {
+            blockId: { type: 'string', description: 'The block UUID' },
+            path: {
+              type: 'string',
+              description: "The output path (e.g. 'response', 'response.content')",
+            },
+          },
+          required: ['blockId', 'path'],
+        },
+      },
+      password: { type: 'string', description: 'Password for password-protected chats' },
+      title: { type: 'string', description: 'Display title for the chat interface' },
+      welcomeMessage: { type: 'string', description: 'Welcome message shown to users' },
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to deploy (required in workspace context)',
+      },
+    },
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DeployMcp: ToolCatalogEntry = {
+  id: 'deploy_mcp',
+  name: 'deploy_mcp',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      parameterDescriptions: {
+        type: 'array',
+        description: 'Array of parameter descriptions for the tool',
+        items: {
+          type: 'object',
+          properties: {
+            description: { type: 'string', description: 'Parameter description' },
+            name: { type: 'string', description: 'Parameter name' },
+          },
+          required: ['name', 'description'],
+        },
+      },
+      serverId: {
+        type: 'string',
+        description: 'Required: server ID from list_workspace_mcp_servers',
+      },
+      toolDescription: { type: 'string', description: 'Description for the MCP tool' },
+      toolName: {
+        type: 'string',
+        description: 'Name for the MCP tool (defaults to workflow name)',
+      },
+      workflowId: { type: 'string', description: 'Workflow ID (defaults to active workflow)' },
+    },
+    required: ['serverId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DownloadToWorkspaceFile: ToolCatalogEntry = {
+  id: 'download_to_workspace_file',
+  name: 'download_to_workspace_file',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fileName: {
+        type: 'string',
+        description:
+          'Optional workspace file name to save as. If omitted, the name is inferred from the response or URL.',
+      },
+      url: {
+        type: 'string',
+        description:
+          'Direct URL of the file to download, such as an image CDN URL ending in .png or .jpg',
+      },
+    },
+    required: ['url'],
+  },
+  requiredPermission: 'write',
+}
+
+export const EditWorkflow: ToolCatalogEntry = {
+  id: 'edit_workflow',
+  name: 'edit_workflow',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operations: {
+        type: 'array',
+        description: 'Array of edit operations',
+        items: {
+          type: 'object',
+          properties: {
+            block_id: {
+              type: 'string',
+              description:
+                'Block ID for the operation. For add operations, this will be the desired ID for the new block.',
+            },
+            operation_type: {
+              type: 'string',
+              description: 'Type of operation to perform',
+              enum: ['add', 'edit', 'delete', 'insert_into_subflow', 'extract_from_subflow'],
+            },
+            params: {
+              type: 'object',
+              description:
+                'Parameters for the operation. \nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "gpt-4o"}}\nFor delete: {} (empty object)',
+            },
+          },
+          required: ['operation_type', 'block_id', 'params'],
+        },
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to edit. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['operations'],
+  },
+  requiredPermission: 'write',
+}
+
+export const File: ToolCatalogEntry = {
+  id: 'file',
+  name: 'file',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: { type: 'object' },
+  subagentId: 'file',
+  internal: true,
+}
+
+export const FunctionExecute: ToolCatalogEntry = {
+  id: 'function_execute',
+  name: 'function_execute',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with access to pre-installed CLI tools and workspace env vars as $VAR_NAME.',
+      },
+      inputFiles: {
+        type: 'array',
+        description:
+          'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}. Example: ["wf_123"]',
+        items: { type: 'string' },
+      },
+      inputTables: {
+        type: 'array',
+        description:
+          'Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Example: ["tbl_abc123"]',
+        items: { type: 'string' },
+      },
+      language: {
+        type: 'string',
+        description: 'Execution language.',
+        enum: ['javascript', 'python', 'shell'],
+      },
+      outputFormat: {
+        type: 'string',
+        description:
+          'Format for outputPath. Determines how the code result is serialized. If omitted, inferred from outputPath file extension.',
+        enum: ['json', 'csv', 'txt', 'md', 'html'],
+      },
+      outputMimeType: {
+        type: 'string',
+        description:
+          'MIME type for outputSandboxPath export. Required for binary files: image/png, image/jpeg, application/pdf, etc. Omit for text files.',
+      },
+      outputPath: {
+        type: 'string',
+        description:
+          'Pipe output directly to a NEW workspace file instead of returning in context. ALWAYS use this instead of a separate workspace_file write call. Use a flat path like "files/result.json" — nested paths are not supported.',
+      },
+      outputSandboxPath: {
+        type: 'string',
+        description:
+          'Path to a file created inside the sandbox that should be exported to the workspace. Use together with outputPath.',
+      },
+      outputTable: {
+        type: 'string',
+        description:
+          'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
+      },
+    },
+    required: ['code'],
+  },
+  requiredPermission: 'write',
+}
+
+export const GenerateApiKey: ToolCatalogEntry = {
+  id: 'generate_api_key',
+  name: 'generate_api_key',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description: "A descriptive name for the API key (e.g., 'production-key', 'dev-testing').",
+      },
+      workspaceId: {
+        type: 'string',
+        description: "Optional workspace ID. Defaults to user's default workspace.",
+      },
+    },
+    required: ['name'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const GenerateImage: ToolCatalogEntry = {
+  id: 'generate_image',
+  name: 'generate_image',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      aspectRatio: {
+        type: 'string',
+        description: 'Aspect ratio for the generated image.',
+        enum: ['1:1', '16:9', '9:16', '4:3', '3:4'],
+      },
+      fileName: {
+        type: 'string',
+        description:
+          'Output file name. Defaults to "generated-image.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+      },
+      overwriteFileId: {
+        type: 'string',
+        description:
+          'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update or redo a previously generated image. The file ID is returned by previous generate_image or generate_visualization calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+      },
+      prompt: {
+        type: 'string',
+        description:
+          'Detailed text description of the image to generate, or editing instructions when used with editFileId.',
+      },
+      referenceFileIds: {
+        type: 'array',
+        description:
+          'File IDs of workspace images to include as context for the generation. All images are sent alongside the prompt. Use for: editing a single image (1 file), compositing multiple images together (2+ files), style transfer, face swapping, etc. Order matters — list the primary/base image first.',
+        items: { type: 'string' },
+      },
+    },
+    required: ['prompt'],
+  },
+  requiredPermission: 'write',
+}
+
+export const GenerateVisualization: ToolCatalogEntry = {
+  id: 'generate_visualization',
+  name: 'generate_visualization',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          "Python code that generates a visualization using matplotlib. MUST call plt.savefig('/home/user/output.png', dpi=150, bbox_inches='tight') to produce output.",
+      },
+      fileName: {
+        type: 'string',
+        description:
+          'Output file name. Defaults to "chart.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+      },
+      inputFiles: {
+        type: 'array',
+        description:
+          'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}.',
+        items: { type: 'string' },
+      },
+      inputTables: {
+        type: 'array',
+        description:
+          "Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Read with pandas: pd.read_csv('/home/user/tables/tbl_xxx.csv')",
+        items: { type: 'string' },
+      },
+      overwriteFileId: {
+        type: 'string',
+        description:
+          'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update or redo a previously generated chart. The file ID is returned by previous generate_visualization or generate_image calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+      },
+    },
+    required: ['code'],
+  },
+  requiredPermission: 'write',
+}
+
+export const GetBlockOutputs: ToolCatalogEntry = {
+  id: 'get_block_outputs',
+  name: 'get_block_outputs',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockIds: {
+        type: 'array',
+        description:
+          'Optional array of block UUIDs. If provided, returns outputs only for those blocks. If not provided, returns outputs for all blocks in the workflow.',
+        items: { type: 'string' },
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+  },
+}
+
+export const GetBlockUpstreamReferences: ToolCatalogEntry = {
+  id: 'get_block_upstream_references',
+  name: 'get_block_upstream_references',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockIds: {
+        type: 'array',
+        description:
+          'Required array of block UUIDs (minimum 1). Returns what each block can reference based on its position in the workflow graph.',
+        items: { type: 'string' },
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['blockIds'],
+  },
+}
+
+export const GetDeployedWorkflowState: ToolCatalogEntry = {
+  id: 'get_deployed_workflow_state',
+  name: 'get_deployed_workflow_state',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+  },
+}
+
+export const GetDeploymentVersion: ToolCatalogEntry = {
+  id: 'get_deployment_version',
+  name: 'get_deployment_version',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      version: { type: 'number', description: 'The deployment version number' },
+      workflowId: { type: 'string', description: 'The workflow ID' },
+    },
+    required: ['workflowId', 'version'],
+  },
+}
+
+export const GetExecutionSummary: ToolCatalogEntry = {
+  id: 'get_execution_summary',
+  name: 'get_execution_summary',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'number',
+        description: 'Max number of executions to return (default: 10, max: 20).',
+      },
+      status: {
+        type: 'string',
+        description: "Filter by status: 'success', 'error', or 'all' (default: 'all').",
+        enum: ['success', 'error', 'all'],
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID. If omitted, returns executions across all workflows in the workspace.',
+      },
+      workspaceId: { type: 'string', description: 'Workspace ID to scope executions to.' },
+    },
+    required: ['workspaceId'],
+  },
+}
+
+export const GetJobLogs: ToolCatalogEntry = {
+  id: 'get_job_logs',
+  name: 'get_job_logs',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      executionId: { type: 'string', description: 'Optional execution ID for a specific run.' },
+      includeDetails: {
+        type: 'boolean',
+        description: 'Include tool calls, outputs, and cost details.',
+      },
+      jobId: { type: 'string', description: 'The job (schedule) ID to get logs for.' },
+      limit: { type: 'number', description: 'Max number of entries (default: 3, max: 5)' },
+    },
+    required: ['jobId'],
+  },
+}
+
+export const GetPageContents: ToolCatalogEntry = {
+  id: 'get_page_contents',
+  name: 'get_page_contents',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      include_highlights: {
+        type: 'boolean',
+        description: 'Include key highlights (default false)',
+      },
+      include_summary: {
+        type: 'boolean',
+        description: 'Include AI-generated summary (default false)',
+      },
+      include_text: { type: 'boolean', description: 'Include full page text (default true)' },
+      urls: {
+        type: 'array',
+        description: 'URLs to get content from (max 10)',
+        items: { type: 'string' },
+      },
+    },
+    required: ['urls'],
+  },
+}
+
+export const GetPlatformActions: ToolCatalogEntry = {
+  id: 'get_platform_actions',
+  name: 'get_platform_actions',
+  executor: 'sim',
+  mode: 'async',
+  parameters: { type: 'object', properties: {} },
+}
+
+export const GetWorkflowData: ToolCatalogEntry = {
+  id: 'get_workflow_data',
+  name: 'get_workflow_data',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      data_type: {
+        type: 'string',
+        description: 'The type of workflow data to retrieve',
+        enum: ['global_variables', 'custom_tools', 'mcp_tools', 'files'],
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['data_type'],
+  },
+}
+
+export const GetWorkflowLogs: ToolCatalogEntry = {
+  id: 'get_workflow_logs',
+  name: 'get_workflow_logs',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      executionId: {
+        type: 'string',
+        description:
+          'Optional execution ID to get logs for a specific execution. Use with get_execution_summary to find execution IDs first.',
+      },
+      includeDetails: { type: 'boolean', description: 'Include detailed info' },
+      limit: { type: 'number', description: 'Max number of entries (hard limit: 3)' },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+  },
+}
+
+export const Glob: ToolCatalogEntry = {
+  id: 'glob',
+  name: 'glob',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description:
+          'Glob pattern to match file paths. Supports * (any segment) and ** (any depth).',
+      },
+    },
+    required: ['pattern'],
+  },
+}
+
+export const Grep: ToolCatalogEntry = {
+  id: 'grep',
+  name: 'grep',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      context: {
+        type: 'number',
+        description:
+          "Number of lines to show before and after each match. Only applies to output_mode 'content'.",
+      },
+      ignoreCase: { type: 'boolean', description: 'Case insensitive search (default false).' },
+      lineNumbers: {
+        type: 'boolean',
+        description:
+          "Include line numbers in output (default true). Only applies to output_mode 'content'.",
+      },
+      maxResults: {
+        type: 'number',
+        description: 'Maximum number of matches to return (default 50).',
+      },
+      output_mode: {
+        type: 'string',
+        description:
+          "Output mode: 'content' shows matching lines (default), 'files_with_matches' shows only file paths, 'count' shows match counts per file.",
+        enum: ['content', 'files_with_matches', 'count'],
+      },
+      path: {
+        type: 'string',
+        description:
+          "Optional path prefix to scope the search (e.g. 'workflows/', 'environment/', 'internal/', 'components/blocks/').",
+      },
+      pattern: { type: 'string', description: 'Regex pattern to search for in file contents.' },
+    },
+    required: ['pattern'],
+  },
+}
+
+export const Job: ToolCatalogEntry = {
+  id: 'job',
+  name: 'job',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: { request: { description: 'What job action is needed.', type: 'string' } },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'job',
+  internal: true,
+}
+
+export const Knowledge: ToolCatalogEntry = {
+  id: 'knowledge',
+  name: 'knowledge',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What knowledge base action is needed.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'knowledge',
+  internal: true,
+}
+
+export const KnowledgeBase: ToolCatalogEntry = {
+  id: 'knowledge_base',
+  name: 'knowledge_base',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          apiKey: {
+            type: 'string',
+            description:
+              'API key for API-key-based connectors (required when connector auth mode is apiKey)',
+          },
+          chunkingConfig: {
+            type: 'object',
+            description: "Chunking configuration (optional for 'create')",
+            properties: {
+              maxSize: {
+                type: 'number',
+                description: 'Maximum chunk size (100-4000, default: 1024)',
+                default: 1024,
+              },
+              minSize: {
+                type: 'number',
+                description: 'Minimum chunk size (1-2000, default: 1)',
+                default: 1,
+              },
+              overlap: {
+                type: 'number',
+                description: 'Overlap between chunks (0-500, default: 200)',
+                default: 200,
+              },
+            },
+          },
+          connectorId: {
+            type: 'string',
+            description:
+              'Connector ID (required for update_connector, delete_connector, sync_connector)',
+          },
+          connectorStatus: {
+            type: 'string',
+            description: 'Connector status (optional for update_connector)',
+            enum: ['active', 'paused'],
+          },
+          connectorType: {
+            type: 'string',
+            description:
+              "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
+          },
+          credentialId: {
+            type: 'string',
+            description:
+              'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
+          },
+          description: {
+            type: 'string',
+            description: "Description of the knowledge base (optional for 'create')",
+          },
+          disabledTagIds: {
+            type: 'array',
+            description:
+              'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
+          },
+          documentId: {
+            type: 'string',
+            description: 'Document ID (required for delete_document, update_document)',
+          },
+          enabled: {
+            type: 'boolean',
+            description: 'Enable/disable a document (optional for update_document)',
+          },
+          fileId: {
+            type: 'string',
+            description:
+              'Canonical workspace file ID to add as a document (preferred for add_file). Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+          },
+          filePath: {
+            type: 'string',
+            description: 'Legacy workspace file reference for add_file. Prefer fileId.',
+          },
+          filename: {
+            type: 'string',
+            description: 'New filename for a document (optional for update_document)',
+          },
+          knowledgeBaseId: {
+            type: 'string',
+            description:
+              'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
+          },
+          name: {
+            type: 'string',
+            description: "Name of the knowledge base (required for 'create')",
+          },
+          query: { type: 'string', description: "Search query text (required for 'query')" },
+          sourceConfig: {
+            type: 'object',
+            description:
+              'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
+          },
+          syncIntervalMinutes: {
+            type: 'number',
+            description:
+              'Sync interval in minutes: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
+            default: 1440,
+          },
+          tagDefinitionId: {
+            type: 'string',
+            description: 'Tag definition ID (required for update_tag, delete_tag)',
+          },
+          tagDisplayName: {
+            type: 'string',
+            description:
+              'Display name for the tag (required for create_tag, optional for update_tag)',
+          },
+          tagFieldType: {
+            type: 'string',
+            description:
+              'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
+            enum: ['text', 'number', 'date', 'boolean'],
+          },
+          topK: {
+            type: 'number',
+            description: 'Number of results to return (1-50, default: 5)',
+            default: 5,
+          },
+          workspaceId: {
+            type: 'string',
+            description: "Workspace ID (required for 'create', optional filter for 'list')",
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: [
+          'create',
+          'get',
+          'query',
+          'add_file',
+          'update',
+          'delete',
+          'delete_document',
+          'update_document',
+          'list_tags',
+          'create_tag',
+          'update_tag',
+          'delete_tag',
+          'get_tag_usage',
+          'add_connector',
+          'update_connector',
+          'delete_connector',
+          'sync_connector',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiresConfirmation: true,
+}
+
+export const ListFolders: ToolCatalogEntry = {
+  id: 'list_folders',
+  name: 'list_folders',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workspaceId: { type: 'string', description: 'Optional workspace ID to list folders for.' },
+    },
+  },
+}
+
+export const ListUserWorkspaces: ToolCatalogEntry = {
+  id: 'list_user_workspaces',
+  name: 'list_user_workspaces',
+  executor: 'sim',
+  mode: 'async',
+  parameters: { type: 'object', properties: {} },
+}
+
+export const ListWorkspaceMcpServers: ToolCatalogEntry = {
+  id: 'list_workspace_mcp_servers',
+  name: 'list_workspace_mcp_servers',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workspaceId: { type: 'string', description: 'Workspace ID (defaults to current workspace)' },
+    },
+  },
+}
+
+export const ManageCredential: ToolCatalogEntry = {
+  id: 'manage_credential',
+  name: 'manage_credential',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      credentialId: {
+        type: 'string',
+        description: 'The credential ID (from environment/credentials.json)',
+      },
+      displayName: { type: 'string', description: 'New display name (required for rename)' },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: ['rename', 'delete'],
+      },
+    },
+    required: ['operation', 'credentialId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const ManageCustomTool: ToolCatalogEntry = {
+  id: 'manage_custom_tool',
+  name: 'manage_custom_tool',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          'The JavaScript code that executes when the tool is called (required for add). Parameters from schema are available as variables. Function body only - no signature or wrapping braces.',
+      },
+      operation: {
+        type: 'string',
+        description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+        enum: ['add', 'edit', 'delete', 'list'],
+      },
+      schema: {
+        type: 'object',
+        description: 'The tool schema in OpenAI function calling format (required for add).',
+        properties: {
+          function: {
+            type: 'object',
+            description: 'The function definition',
+            properties: {
+              description: { type: 'string', description: 'What the function does' },
+              name: { type: 'string', description: 'The function name (camelCase)' },
+              parameters: {
+                type: 'object',
+                description: 'The function parameters schema',
+                properties: {
+                  properties: {
+                    type: 'object',
+                    description: 'Parameter definitions as key-value pairs',
+                  },
+                  required: {
+                    type: 'array',
+                    description: 'Array of required parameter names',
+                    items: { type: 'string' },
+                  },
+                  type: { type: 'string', description: "Must be 'object'" },
+                },
+                required: ['type', 'properties'],
+              },
+            },
+            required: ['name', 'parameters'],
+          },
+          type: { type: 'string', description: "Must be 'function'" },
+        },
+        required: ['type', 'function'],
+      },
+      toolId: {
+        type: 'string',
+        description:
+          "The ID of the custom tool (required for edit/delete). Must be the exact toolId from the get_workflow_data custom tool response - do not guess or construct it. DO NOT PROVIDE THE TOOL ID IF THE OPERATION IS 'ADD'.",
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+}
+
+export const ManageJob: ToolCatalogEntry = {
+  id: 'manage_job',
+  name: 'manage_job',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description:
+          'Operation-specific arguments. For create: {title, prompt, cron?, time?, timezone?, lifecycle?, successCondition?, maxRuns?}. For get/delete: {jobId}. For update: {jobId, title?, prompt?, cron?, timezone?, status?, lifecycle?, successCondition?, maxRuns?}. For list: no args needed.',
+        properties: {
+          cron: { type: 'string', description: 'Cron expression for recurring jobs' },
+          jobId: { type: 'string', description: 'Job ID (required for get, update, delete)' },
+          lifecycle: {
+            type: 'string',
+            description:
+              "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called.",
+          },
+          maxRuns: {
+            type: 'integer',
+            description: 'Max executions before auto-completing. Safety limit.',
+          },
+          prompt: { type: 'string', description: 'The prompt to execute when the job fires' },
+          status: { type: 'string', description: 'Job status: active, paused' },
+          successCondition: {
+            type: 'string',
+            description:
+              'What must happen for the job to be considered complete (until_complete lifecycle).',
+          },
+          time: {
+            type: 'string',
+            description: 'ISO 8601 datetime for one-time jobs or cron start time',
+          },
+          timezone: {
+            type: 'string',
+            description: 'IANA timezone (e.g. America/New_York). Defaults to UTC.',
+          },
+          title: {
+            type: 'string',
+            description: "Short descriptive title for the job (e.g. 'Email Poller')",
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform: create, list, get, update, delete',
+        enum: ['create', 'list', 'get', 'update', 'delete'],
+      },
+    },
+    required: ['operation'],
+  },
+}
+
+export const ManageMcpTool: ToolCatalogEntry = {
+  id: 'manage_mcp_tool',
+  name: 'manage_mcp_tool',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      config: {
+        type: 'object',
+        description: 'Required for add and edit. The MCP server configuration.',
+        properties: {
+          enabled: {
+            type: 'boolean',
+            description: 'Whether the server is enabled (default: true)',
+          },
+          headers: {
+            type: 'object',
+            description: 'Optional HTTP headers to send with requests (key-value pairs)',
+          },
+          name: { type: 'string', description: 'Display name for the MCP server' },
+          timeout: {
+            type: 'number',
+            description: 'Request timeout in milliseconds (default: 30000)',
+          },
+          transport: {
+            type: 'string',
+            description: "Transport protocol: 'streamable-http' or 'sse'",
+            enum: ['streamable-http', 'sse'],
+            default: 'streamable-http',
+          },
+          url: { type: 'string', description: 'The MCP server endpoint URL (required for add)' },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+        enum: ['add', 'edit', 'delete', 'list'],
+      },
+      serverId: {
+        type: 'string',
+        description:
+          "Required for edit and delete. The database ID of the MCP server. DO NOT PROVIDE if operation is 'add' or 'list'.",
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const ManageSkill: ToolCatalogEntry = {
+  id: 'manage_skill',
+  name: 'manage_skill',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'Markdown instructions for the skill. Required for add, optional for edit.',
+      },
+      description: {
+        type: 'string',
+        description: 'Short description of the skill. Required for add, optional for edit.',
+      },
+      name: {
+        type: 'string',
+        description:
+          "Skill name in kebab-case (e.g. 'my-skill'). Required for add, optional for edit.",
+      },
+      operation: {
+        type: 'string',
+        description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+        enum: ['add', 'edit', 'delete', 'list'],
+      },
+      skillId: {
+        type: 'string',
+        description:
+          "The ID of the skill (required for edit/delete). Must be the exact ID from the VFS or list. DO NOT PROVIDE if operation is 'add' or 'list'.",
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const MaterializeFile: ToolCatalogEntry = {
+  id: 'materialize_file',
+  name: 'materialize_file',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fileName: {
+        type: 'string',
+        description: 'The name of the uploaded file to materialize (e.g. "report.pdf")',
+      },
+      knowledgeBaseId: {
+        type: 'string',
+        description:
+          'ID of an existing knowledge base to add the file to (only used with operation "knowledge_base"). If omitted, a new KB is created.',
+      },
+      operation: {
+        type: 'string',
+        description:
+          'What to do with the file. "save" promotes it to files/. "import" imports a workflow JSON. "table" converts CSV/TSV/JSON to a table. "knowledge_base" saves and adds to a KB. Defaults to "save".',
+        enum: ['save', 'import', 'table', 'knowledge_base'],
+        default: 'save',
+      },
+      tableName: {
+        type: 'string',
+        description:
+          'Custom name for the table (only used with operation "table"). Defaults to the file name without extension.',
+      },
+    },
+    required: ['fileName'],
+  },
+  requiredPermission: 'write',
+}
+
+export const MoveFolder: ToolCatalogEntry = {
+  id: 'move_folder',
+  name: 'move_folder',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      folderId: { type: 'string', description: 'The folder ID to move.' },
+      parentId: {
+        type: 'string',
+        description:
+          'Target parent folder ID. Omit or pass empty string to move to workspace root.',
+      },
+    },
+    required: ['folderId'],
+  },
+  requiredPermission: 'write',
+}
+
+export const MoveWorkflow: ToolCatalogEntry = {
+  id: 'move_workflow',
+  name: 'move_workflow',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      folderId: {
+        type: 'string',
+        description: 'Target folder ID. Omit or pass empty string to move to workspace root.',
+      },
+      workflowId: { type: 'string', description: 'The workflow ID to move.' },
+    },
+    required: ['workflowId'],
+  },
+  requiredPermission: 'write',
+}
+
+export const OauthGetAuthLink: ToolCatalogEntry = {
+  id: 'oauth_get_auth_link',
+  name: 'oauth_get_auth_link',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      providerName: {
+        type: 'string',
+        description:
+          "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar', 'GitHub')",
+      },
+    },
+    required: ['providerName'],
+  },
+}
+
+export const OauthRequestAccess: ToolCatalogEntry = {
+  id: 'oauth_request_access',
+  name: 'oauth_request_access',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      providerName: {
+        type: 'string',
+        description:
+          "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar')",
+      },
+    },
+    required: ['providerName'],
+  },
+  requiresConfirmation: true,
+}
+
+export const OpenResource: ToolCatalogEntry = {
+  id: 'open_resource',
+  name: 'open_resource',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      id: { type: 'string', description: 'The resource ID to open.' },
+      type: {
+        type: 'string',
+        description: 'The resource type to open.',
+        enum: ['workflow', 'table', 'knowledgebase', 'file'],
+      },
+    },
+    required: ['type', 'id'],
+  },
+}
+
+export const Read: ToolCatalogEntry = {
+  id: 'read',
+  name: 'read',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      limit: { type: 'number', description: 'Maximum number of lines to read.' },
+      offset: { type: 'number', description: 'Line offset to start reading from (0-indexed).' },
+      outputTable: {
+        type: 'string',
+        description:
+          'Table ID to import the file contents into (CSV/JSON). All existing rows are replaced. Example: "tbl_abc123"',
+      },
+      path: {
+        type: 'string',
+        description: "Path to the file to read (e.g. 'workflows/My Workflow/state.json').",
+      },
+    },
+    required: ['path'],
+  },
+}
+
+export const Redeploy: ToolCatalogEntry = {
+  id: 'redeploy',
+  name: 'redeploy',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to redeploy (required in workspace context)',
+      },
+    },
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const RenameWorkflow: ToolCatalogEntry = {
+  id: 'rename_workflow',
+  name: 'rename_workflow',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'The new name for the workflow.' },
+      workflowId: { type: 'string', description: 'The workflow ID to rename.' },
+    },
+    required: ['workflowId', 'name'],
+  },
+  requiredPermission: 'write',
+}
+
+export const Research: ToolCatalogEntry = {
+  id: 'research',
+  name: 'research',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: { topic: { description: 'The topic to research.', type: 'string' } },
+    required: ['topic'],
+    type: 'object',
+  },
+  subagentId: 'research',
+  internal: true,
+}
+
+export const Respond: ToolCatalogEntry = {
+  id: 'respond',
+  name: 'respond',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    additionalProperties: true,
+    properties: {
+      output: {
+        description:
+          'The result — facts, status, VFS paths to persisted data, whatever the caller needs to act on.',
+        type: 'string',
+      },
+      success: { description: 'Whether the task completed successfully', type: 'boolean' },
+      type: { description: 'Optional logical result type override', type: 'string' },
+    },
+    required: ['output', 'success'],
+    type: 'object',
+  },
+  internal: true,
+  hidden: true,
+}
+
+export const RevertToVersion: ToolCatalogEntry = {
+  id: 'revert_to_version',
+  name: 'revert_to_version',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      version: { type: 'number', description: 'The deployment version number to revert to' },
+      workflowId: { type: 'string', description: 'The workflow ID' },
+    },
+    required: ['workflowId', 'version'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const Run: ToolCatalogEntry = {
+  id: 'run',
+  name: 'run',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      context: {
+        description: 'Pre-gathered context: workflow state, block IDs, input requirements.',
+        type: 'string',
+      },
+      request: { description: 'What to run or what logs to check.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'run',
+  internal: true,
+}
+
+export const RunBlock: ToolCatalogEntry = {
+  id: 'run_block',
+  name: 'run_block',
+  executor: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockId: { type: 'string', description: 'The block ID to run in isolation.' },
+      executionId: {
+        type: 'string',
+        description:
+          'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+      },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['blockId'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const RunFromBlock: ToolCatalogEntry = {
+  id: 'run_from_block',
+  name: 'run_from_block',
+  executor: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      executionId: {
+        type: 'string',
+        description:
+          'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+      },
+      startBlockId: { type: 'string', description: 'The block ID to start execution from.' },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['startBlockId'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const RunWorkflow: ToolCatalogEntry = {
+  id: 'run_workflow',
+  name: 'run_workflow',
+  executor: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['workflow_input'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const RunWorkflowUntilBlock: ToolCatalogEntry = {
+  id: 'run_workflow_until_block',
+  name: 'run_workflow_until_block',
+  executor: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      stopAfterBlockId: {
+        type: 'string',
+        description: 'The block ID to stop after. Execution halts once this block completes.',
+      },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['stopAfterBlockId'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const ScrapePage: ToolCatalogEntry = {
+  id: 'scrape_page',
+  name: 'scrape_page',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      include_links: {
+        type: 'boolean',
+        description: 'Extract all links from the page (default false)',
+      },
+      url: { type: 'string', description: 'The URL to scrape (must include https://)' },
+      wait_for: {
+        type: 'string',
+        description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+      },
+    },
+    required: ['url'],
+  },
+}
+
+export const SearchDocumentation: ToolCatalogEntry = {
+  id: 'search_documentation',
+  name: 'search_documentation',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'The search query' },
+      topK: { type: 'number', description: 'Number of results (max 10)' },
+    },
+    required: ['query'],
+  },
+}
+
+export const SearchLibraryDocs: ToolCatalogEntry = {
+  id: 'search_library_docs',
+  name: 'search_library_docs',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      library_name: {
+        type: 'string',
+        description: "Name of the library to search for (e.g., 'nextjs', 'stripe', 'langchain')",
+      },
+      query: {
+        type: 'string',
+        description: 'The question or topic to find documentation for - be specific',
+      },
+      version: { type: 'string', description: "Specific version (optional, e.g., '14', 'v2')" },
+    },
+    required: ['library_name', 'query'],
+  },
+}
+
+export const SearchOnline: ToolCatalogEntry = {
+  id: 'search_online',
+  name: 'search_online',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        description: 'Filter by category',
+        enum: [
+          'news',
+          'tweet',
+          'github',
+          'paper',
+          'company',
+          'research paper',
+          'linkedin profile',
+          'pdf',
+          'personal site',
+        ],
+      },
+      include_text: { type: 'boolean', description: 'Include page text content (default true)' },
+      num_results: { type: 'number', description: 'Number of results (default 10, max 25)' },
+      query: { type: 'string', description: 'Natural language search query' },
+    },
+    required: ['query'],
+  },
+}
+
+export const SearchPatterns: ToolCatalogEntry = {
+  id: 'search_patterns',
+  name: 'search_patterns',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'integer',
+        description: 'Maximum number of unique pattern examples to return (defaults to 3).',
+      },
+      queries: {
+        type: 'array',
+        description:
+          'Up to 3 descriptive strings explaining the workflow pattern(s) you need. Focus on intent and desired outcomes.',
+        items: {
+          type: 'string',
+          description: 'Example: "how to automate wealthbox meeting notes into follow-up tasks"',
+        },
+      },
+    },
+    required: ['queries'],
+  },
+}
+
+export const SetEnvironmentVariables: ToolCatalogEntry = {
+  id: 'set_environment_variables',
+  name: 'set_environment_variables',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      variables: {
+        type: 'array',
+        description: 'List of env vars to set',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Variable name' },
+            value: { type: 'string', description: 'Variable value' },
+          },
+          required: ['name', 'value'],
+        },
+      },
+    },
+    required: ['variables'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const SetGlobalWorkflowVariables: ToolCatalogEntry = {
+  id: 'set_global_workflow_variables',
+  name: 'set_global_workflow_variables',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operations: {
+        type: 'array',
+        description: 'List of operations to apply',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            operation: { type: 'string', enum: ['add', 'delete', 'edit'] },
+            type: { type: 'string', enum: ['plain', 'number', 'boolean', 'array', 'object'] },
+            value: { type: 'string' },
+          },
+          required: ['operation', 'name', 'type', 'value'],
+        },
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['operations'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const Superagent: ToolCatalogEntry = {
+  id: 'superagent',
+  name: 'superagent',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      task: {
+        description:
+          "A single sentence — the agent has full conversation context. Do NOT pre-read credentials or look up configs. Example: 'send the email we discussed' or 'check my calendar for tomorrow'.",
+        type: 'string',
+      },
+    },
+    required: ['task'],
+    type: 'object',
+  },
+  subagentId: 'superagent',
+  internal: true,
+}
+
+export const Table: ToolCatalogEntry = {
+  id: 'table',
+  name: 'table',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: { request: { description: 'What table action is needed.', type: 'string' } },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'table',
+  internal: true,
+}
+
+export const ToolSearchToolRegex: ToolCatalogEntry = {
+  id: 'tool_search_tool_regex',
+  name: 'tool_search_tool_regex',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    properties: {
+      case_insensitive: {
+        description: 'Whether the regex should be case-insensitive (default true).',
+        type: 'boolean',
+      },
+      max_results: {
+        description: 'Maximum number of tools to return (optional).',
+        type: 'integer',
+      },
+      pattern: {
+        description: 'Regular expression to match tool names or descriptions.',
+        type: 'string',
+      },
+    },
+    required: ['pattern'],
+    type: 'object',
+  },
+}
+
+export const UpdateJobHistory: ToolCatalogEntry = {
+  id: 'update_job_history',
+  name: 'update_job_history',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      jobId: { type: 'string', description: 'The job ID.' },
+      summary: {
+        type: 'string',
+        description:
+          "A concise summary of what was done this run (e.g., 'Sent follow-up emails to 3 leads: Alice, Bob, Carol').",
+      },
+    },
+    required: ['jobId', 'summary'],
+  },
+}
+
+export const UpdateWorkspaceMcpServer: ToolCatalogEntry = {
+  id: 'update_workspace_mcp_server',
+  name: 'update_workspace_mcp_server',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      description: { type: 'string', description: 'New description for the server' },
+      isPublic: { type: 'boolean', description: 'Whether the server is publicly accessible' },
+      name: { type: 'string', description: 'New name for the server' },
+      serverId: { type: 'string', description: 'Required: the MCP server ID to update' },
+    },
+    required: ['serverId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const UserMemory: ToolCatalogEntry = {
+  id: 'user_memory',
+  name: 'user_memory',
+  executor: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      confidence: {
+        type: 'number',
+        description: 'Confidence level 0-1 (default 1.0 for explicit, 0.8 for inferred)',
+      },
+      correct_value: {
+        type: 'string',
+        description: "The correct value to replace the wrong one (for 'correct' operation)",
+      },
+      key: {
+        type: 'string',
+        description: "Unique key for the memory (e.g., 'preferred_model', 'slack_credential')",
+      },
+      limit: { type: 'number', description: 'Number of results for search (default 10)' },
+      memory_type: {
+        type: 'string',
+        description: "Type of memory: 'preference', 'entity', 'history', or 'correction'",
+        enum: ['preference', 'entity', 'history', 'correction'],
+      },
+      operation: {
+        type: 'string',
+        description: "Operation: 'add', 'search', 'delete', 'correct', or 'list'",
+        enum: ['add', 'search', 'delete', 'correct', 'list'],
+      },
+      query: { type: 'string', description: 'Search query to find relevant memories' },
+      source: {
+        type: 'string',
+        description: "Source: 'explicit' (user told you) or 'inferred' (you observed)",
+        enum: ['explicit', 'inferred'],
+      },
+      value: { type: 'string', description: 'Value to remember' },
+    },
+    required: ['operation'],
+  },
+}
+
+export const UserTable: ToolCatalogEntry = {
+  id: 'user_table',
+  name: 'user_table',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          column: {
+            type: 'object',
+            description: 'Column definition for add_column: { name, type, unique?, position? }',
+          },
+          columnName: {
+            type: 'string',
+            description:
+              'Column name (required for rename_column, update_column; use columnNames array for batch delete_column)',
+          },
+          columnNames: {
+            type: 'array',
+            description:
+              'Array of column names to delete at once (for delete_column). Preferred over columnName when deleting multiple columns.',
+          },
+          data: {
+            type: 'object',
+            description: 'Row data as key-value pairs (required for insert_row, update_row)',
+          },
+          description: { type: 'string', description: "Table description (optional for 'create')" },
+          fileId: {
+            type: 'string',
+            description:
+              'Canonical workspace file ID for create_from_file/import_file. Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+          },
+          filePath: {
+            type: 'string',
+            description:
+              'Legacy workspace file reference for create_from_file/import_file. Prefer fileId.',
+          },
+          filter: {
+            type: 'object',
+            description:
+              'MongoDB-style filter for query_rows, update_rows_by_filter, delete_rows_by_filter',
+          },
+          limit: {
+            type: 'number',
+            description: 'Maximum rows to return or affect (optional, default 100)',
+          },
+          name: { type: 'string', description: "Table name (required for 'create')" },
+          newName: { type: 'string', description: 'New column name (required for rename_column)' },
+          newType: {
+            type: 'string',
+            description:
+              'New column type (optional for update_column). Types: string, number, boolean, date, json',
+          },
+          offset: {
+            type: 'number',
+            description: 'Number of rows to skip (optional for query_rows, default 0)',
+          },
+          outputFormat: {
+            type: 'string',
+            description:
+              'Explicit format override for outputPath. Usually unnecessary — the file extension determines the format automatically. Only use this to force a different format than what the extension implies.',
+            enum: ['json', 'csv', 'txt', 'md', 'html'],
+          },
+          outputPath: {
+            type: 'string',
+            description:
+              'Pipe query_rows results directly to a NEW workspace file. The format is auto-inferred from the file extension: .csv → CSV, .json → JSON, .md → Markdown, etc. Use .csv for tabular exports. Use a flat path like "files/export.csv" — nested paths are not supported.',
+          },
+          rowId: {
+            type: 'string',
+            description: 'Row ID (required for get_row, update_row, delete_row)',
+          },
+          rowIds: {
+            type: 'array',
+            description: 'Array of row IDs to delete (for batch_delete_rows)',
+          },
+          rows: {
+            type: 'array',
+            description: 'Array of row data objects (required for batch_insert_rows)',
+          },
+          schema: {
+            type: 'object',
+            description:
+              "Table schema with columns array (required for 'create'). Each column: { name, type, unique? }",
+          },
+          sort: {
+            type: 'object',
+            description:
+              "Sort specification as { field: 'asc' | 'desc' } (optional for query_rows)",
+          },
+          tableId: {
+            type: 'string',
+            description: "Table ID (required for most operations except 'create')",
+          },
+          unique: {
+            type: 'boolean',
+            description: 'Set column unique constraint (optional for update_column)',
+          },
+          updates: {
+            type: 'array',
+            description:
+              'Array of per-row updates: [{ rowId, data: { col: val } }] (for batch_update_rows)',
+          },
+          values: {
+            type: 'object',
+            description:
+              'Map of rowId to value for single-column batch update: { "rowId1": val1, "rowId2": val2 } (for batch_update_rows with columnName)',
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: [
+          'create',
+          'create_from_file',
+          'import_file',
+          'get',
+          'get_schema',
+          'delete',
+          'insert_row',
+          'batch_insert_rows',
+          'get_row',
+          'query_rows',
+          'update_row',
+          'delete_row',
+          'update_rows_by_filter',
+          'delete_rows_by_filter',
+          'batch_update_rows',
+          'batch_delete_rows',
+          'add_column',
+          'rename_column',
+          'delete_column',
+          'update_column',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiresConfirmation: true,
+}
+
+export const Workflow: ToolCatalogEntry = {
+  id: 'workflow',
+  name: 'workflow',
+  executor: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: {
+        description:
+          "A single sentence — the agent has full conversation context and VFS access. Do NOT look up IDs or pre-read data; the workflow agent does its own research. Example: 'move all the return letter workflows into a folder called Letters'.",
+        type: 'string',
+      },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'workflow',
+  internal: true,
+}
+
+export const WorkspaceFile: ToolCatalogEntry = {
+  id: 'workspace_file',
+  name: 'workspace_file',
+  executor: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operation: {
+        type: 'string',
+        description: 'The file operation to perform.',
+        enum: ['create', 'append', 'update', 'patch', 'rename', 'delete'],
+      },
+      target: {
+        type: 'object',
+        description:
+          'Explicit file target. Use kind=new_file + fileName for create. Use kind=file_id + fileId for append, update, patch, rename, and delete. Emit target keys in this order: kind, fileId, fileName.',
+        properties: {
+          kind: {
+            type: 'string',
+            description: 'How the file target is identified.',
+            enum: ['new_file', 'file_id'],
+          },
+          fileId: {
+            type: 'string',
+            description: 'Canonical existing workspace file ID. Required when target.kind=file_id.',
+          },
+          fileName: {
+            type: 'string',
+            description:
+              'Plain workspace filename including extension, e.g. "main.py" or "report.docx". Required when target.kind=new_file.',
+          },
+        },
+        required: ['kind'],
+      },
+      title: {
+        type: 'string',
+        description:
+          'Optional short UI label for create/append chunks, e.g. "Chapter 1" or "Slide 3".',
+      },
+      contentType: {
+        type: 'string',
+        description:
+          'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
+        enum: [
+          'text/markdown',
+          'text/html',
+          'text/plain',
+          'application/json',
+          'text/csv',
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+          'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+          'application/pdf',
+        ],
+      },
+      edit: {
+        type: 'object',
+        description:
+          'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. Emit edit keys in this order: strategy, search, replace, replaceAll, mode, occurrence, before_anchor, after_anchor, anchor, start_anchor, end_anchor, content.',
+        properties: {
+          strategy: {
+            type: 'string',
+            description: 'Patch strategy.',
+            enum: ['search_replace', 'anchored'],
+          },
+          search: {
+            type: 'string',
+            description:
+              'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
+          },
+          replace: {
+            type: 'string',
+            description: 'Replacement text when strategy=search_replace.',
+          },
+          replaceAll: {
+            type: 'boolean',
+            description:
+              'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
+          },
+          mode: {
+            type: 'string',
+            description: 'Anchored edit mode when strategy=anchored.',
+            enum: ['replace_between', 'insert_after', 'delete_between'],
+          },
+          occurrence: {
+            type: 'number',
+            description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
+          },
+          before_anchor: {
+            type: 'string',
+            description:
+              'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
+          },
+          after_anchor: {
+            type: 'string',
+            description:
+              'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
+          },
+          anchor: {
+            type: 'string',
+            description:
+              'Anchor line after which new content is inserted. Required for mode=insert_after.',
+          },
+          start_anchor: {
+            type: 'string',
+            description: 'First line to delete. Required for mode=delete_between.',
+          },
+          end_anchor: {
+            type: 'string',
+            description: 'First line to keep after deletion. Required for mode=delete_between.',
+          },
+          content: {
+            type: 'string',
+            description:
+              'Inserted or replacement content for anchored edits. Not used for delete_between.',
+          },
+        },
+      },
+      newName: {
+        type: 'string',
+        description: 'New file name for rename. Must be a plain workspace filename like "main.py".',
+      },
+      content: {
+        type: 'string',
+        description:
+          'File content for create, append, or update. For .pptx/.docx/.pdf this must be JavaScript source code for the corresponding generator runtime.',
+      },
+    },
+    required: ['operation', 'target'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: {
+        type: 'object',
+        description:
+          'Optional operation metadata such as file id, file name, size, and content type.',
+      },
+      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
+      success: { type: 'boolean', description: 'Whether the file operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
+export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
+  [Agent.id]: Agent,
+  [Auth.id]: Auth,
+  [CheckDeploymentStatus.id]: CheckDeploymentStatus,
+  [CompleteJob.id]: CompleteJob,
+  [ContextWrite.id]: ContextWrite,
+  [CrawlWebsite.id]: CrawlWebsite,
+  [CreateFolder.id]: CreateFolder,
+  [CreateJob.id]: CreateJob,
+  [CreateWorkflow.id]: CreateWorkflow,
+  [CreateWorkspaceMcpServer.id]: CreateWorkspaceMcpServer,
+  [Debug.id]: Debug,
+  [DeleteFolder.id]: DeleteFolder,
+  [DeleteWorkflow.id]: DeleteWorkflow,
+  [DeleteWorkspaceMcpServer.id]: DeleteWorkspaceMcpServer,
+  [Deploy.id]: Deploy,
+  [DeployApi.id]: DeployApi,
+  [DeployChat.id]: DeployChat,
+  [DeployMcp.id]: DeployMcp,
+  [DownloadToWorkspaceFile.id]: DownloadToWorkspaceFile,
+  [EditWorkflow.id]: EditWorkflow,
+  [File.id]: File,
+  [FunctionExecute.id]: FunctionExecute,
+  [GenerateApiKey.id]: GenerateApiKey,
+  [GenerateImage.id]: GenerateImage,
+  [GenerateVisualization.id]: GenerateVisualization,
+  [GetBlockOutputs.id]: GetBlockOutputs,
+  [GetBlockUpstreamReferences.id]: GetBlockUpstreamReferences,
+  [GetDeployedWorkflowState.id]: GetDeployedWorkflowState,
+  [GetDeploymentVersion.id]: GetDeploymentVersion,
+  [GetExecutionSummary.id]: GetExecutionSummary,
+  [GetJobLogs.id]: GetJobLogs,
+  [GetPageContents.id]: GetPageContents,
+  [GetPlatformActions.id]: GetPlatformActions,
+  [GetWorkflowData.id]: GetWorkflowData,
+  [GetWorkflowLogs.id]: GetWorkflowLogs,
+  [Glob.id]: Glob,
+  [Grep.id]: Grep,
+  [Job.id]: Job,
+  [Knowledge.id]: Knowledge,
+  [KnowledgeBase.id]: KnowledgeBase,
+  [ListFolders.id]: ListFolders,
+  [ListUserWorkspaces.id]: ListUserWorkspaces,
+  [ListWorkspaceMcpServers.id]: ListWorkspaceMcpServers,
+  [ManageCredential.id]: ManageCredential,
+  [ManageCustomTool.id]: ManageCustomTool,
+  [ManageJob.id]: ManageJob,
+  [ManageMcpTool.id]: ManageMcpTool,
+  [ManageSkill.id]: ManageSkill,
+  [MaterializeFile.id]: MaterializeFile,
+  [MoveFolder.id]: MoveFolder,
+  [MoveWorkflow.id]: MoveWorkflow,
+  [OauthGetAuthLink.id]: OauthGetAuthLink,
+  [OauthRequestAccess.id]: OauthRequestAccess,
+  [OpenResource.id]: OpenResource,
+  [Read.id]: Read,
+  [Redeploy.id]: Redeploy,
+  [RenameWorkflow.id]: RenameWorkflow,
+  [Research.id]: Research,
+  [Respond.id]: Respond,
+  [RevertToVersion.id]: RevertToVersion,
+  [Run.id]: Run,
+  [RunBlock.id]: RunBlock,
+  [RunFromBlock.id]: RunFromBlock,
+  [RunWorkflow.id]: RunWorkflow,
+  [RunWorkflowUntilBlock.id]: RunWorkflowUntilBlock,
+  [ScrapePage.id]: ScrapePage,
+  [SearchDocumentation.id]: SearchDocumentation,
+  [SearchLibraryDocs.id]: SearchLibraryDocs,
+  [SearchOnline.id]: SearchOnline,
+  [SearchPatterns.id]: SearchPatterns,
+  [SetEnvironmentVariables.id]: SetEnvironmentVariables,
+  [SetGlobalWorkflowVariables.id]: SetGlobalWorkflowVariables,
+  [Superagent.id]: Superagent,
+  [Table.id]: Table,
+  [ToolSearchToolRegex.id]: ToolSearchToolRegex,
+  [UpdateJobHistory.id]: UpdateJobHistory,
+  [UpdateWorkspaceMcpServer.id]: UpdateWorkspaceMcpServer,
+  [UserMemory.id]: UserMemory,
+  [UserTable.id]: UserTable,
+  [Workflow.id]: Workflow,
+  [WorkspaceFile.id]: WorkspaceFile,
+}
diff --git a/apps/sim/lib/copilot/generated/tool-schemas-v1.ts b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
new file mode 100644
index 00000000000..904ba5811ef
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
@@ -0,0 +1,2392 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+// Generated from copilot/contracts/tool-catalog-v1.json
+//
+
+export type JsonSchema = unknown
+
+export interface ToolRuntimeSchemaEntry {
+  parameters?: JsonSchema
+  resultSchema?: JsonSchema
+}
+
+export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
+  agent: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What tool/skill/MCP action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  auth: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What authentication/credential action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  check_deployment_status: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to check (defaults to current workflow)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  complete_job: {
+    parameters: {
+      type: 'object',
+      properties: {
+        jobId: {
+          type: 'string',
+          description: 'The ID of the job to mark as completed.',
+        },
+      },
+      required: ['jobId'],
+    },
+    resultSchema: undefined,
+  },
+  context_write: {
+    parameters: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Full content to write to the file (replaces existing content)',
+        },
+        file_path: {
+          type: 'string',
+          description: "Path of the file to write (e.g. 'SESSION.md')",
+        },
+      },
+      required: ['file_path', 'content'],
+    },
+    resultSchema: undefined,
+  },
+  crawl_website: {
+    parameters: {
+      type: 'object',
+      properties: {
+        exclude_paths: {
+          type: 'array',
+          description: 'Skip URLs matching these patterns',
+          items: {
+            type: 'string',
+          },
+        },
+        include_paths: {
+          type: 'array',
+          description: 'Only crawl URLs matching these patterns',
+          items: {
+            type: 'string',
+          },
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum pages to crawl (default 10, max 50)',
+        },
+        max_depth: {
+          type: 'number',
+          description: 'How deep to follow links (default 2)',
+        },
+        url: {
+          type: 'string',
+          description: 'Starting URL to crawl from',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  create_folder: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Folder name.',
+        },
+        parentId: {
+          type: 'string',
+          description: 'Optional parent folder ID.',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Optional workspace ID.',
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  create_job: {
+    parameters: {
+      type: 'object',
+      properties: {
+        cron: {
+          type: 'string',
+          description:
+            "Cron expression for recurring jobs (e.g., '*/5 * * * *' for every 5 minutes, '0 9 * * *' for daily at 9 AM). Omit for one-time jobs.",
+        },
+        lifecycle: {
+          type: 'string',
+          description:
+            "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called after the success condition is met.",
+          enum: ['persistent', 'until_complete'],
+        },
+        maxRuns: {
+          type: 'integer',
+          description:
+            'Maximum number of executions before the job auto-completes. Safety limit to prevent runaway polling.',
+        },
+        prompt: {
+          type: 'string',
+          description:
+            'The prompt to execute when the job fires. This is sent to the Mothership as a user message.',
+        },
+        successCondition: {
+          type: 'string',
+          description:
+            "What must happen for the job to be considered complete. Used with until_complete lifecycle (e.g., 'John has replied to the partnership email').",
+        },
+        time: {
+          type: 'string',
+          description:
+            "ISO 8601 datetime for one-time execution or as the start time for a cron schedule (e.g., '2026-03-06T09:00:00'). Include timezone offset or use the timezone parameter.",
+        },
+        timezone: {
+          type: 'string',
+          description:
+            "IANA timezone for the schedule (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC.",
+        },
+        title: {
+          type: 'string',
+          description:
+            "A short, descriptive title for the job (e.g., 'Email Poller', 'Daily Report'). Used as the display name.",
+        },
+      },
+      required: ['title', 'prompt'],
+    },
+    resultSchema: undefined,
+  },
+  create_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        description: {
+          type: 'string',
+          description: 'Optional workflow description.',
+        },
+        folderId: {
+          type: 'string',
+          description: 'Optional folder ID.',
+        },
+        name: {
+          type: 'string',
+          description: 'Workflow name.',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Optional workspace ID.',
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  create_workspace_mcp_server: {
+    parameters: {
+      type: 'object',
+      properties: {
+        description: {
+          type: 'string',
+          description: 'Optional description for the server',
+        },
+        name: {
+          type: 'string',
+          description: 'Required: server name',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Workspace ID (defaults to current workspace)',
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  debug: {
+    parameters: {
+      properties: {
+        context: {
+          description:
+            'Pre-gathered context: workflow state JSON, block schemas, error logs. The debug agent will skip re-reading anything included here.',
+          type: 'string',
+        },
+        request: {
+          description:
+            'What to debug. Include error messages, block IDs, and any context about the failure.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  delete_folder: {
+    parameters: {
+      type: 'object',
+      properties: {
+        folderId: {
+          type: 'string',
+          description: 'The folder ID to delete.',
+        },
+      },
+      required: ['folderId'],
+    },
+    resultSchema: undefined,
+  },
+  delete_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID to delete.',
+        },
+      },
+      required: ['workflowId'],
+    },
+    resultSchema: undefined,
+  },
+  delete_workspace_mcp_server: {
+    parameters: {
+      type: 'object',
+      properties: {
+        serverId: {
+          type: 'string',
+          description: 'Required: the MCP server ID to delete',
+        },
+      },
+      required: ['serverId'],
+    },
+    resultSchema: undefined,
+  },
+  deploy: {
+    parameters: {
+      properties: {
+        request: {
+          description:
+            'Detailed deployment instructions. Include deployment type (api/chat) and ALL user-specified options: identifier, title, description, authType, password, allowedEmails, welcomeMessage, outputConfigs (block outputs to display).',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  deploy_api: {
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Whether to deploy or undeploy the API endpoint',
+          enum: ['deploy', 'undeploy'],
+          default: 'deploy',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to deploy (required in workspace context)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  deploy_chat: {
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Whether to deploy or undeploy the chat interface',
+          enum: ['deploy', 'undeploy'],
+          default: 'deploy',
+        },
+        allowedEmails: {
+          type: 'array',
+          description: 'List of allowed emails/domains for email or SSO auth',
+          items: {
+            type: 'string',
+          },
+        },
+        authType: {
+          type: 'string',
+          description: 'Authentication type: public, password, email, or sso',
+          enum: ['public', 'password', 'email', 'sso'],
+          default: 'public',
+        },
+        description: {
+          type: 'string',
+          description: 'Optional description for the chat',
+        },
+        identifier: {
+          type: 'string',
+          description: 'URL slug for the chat (lowercase letters, numbers, hyphens only)',
+        },
+        outputConfigs: {
+          type: 'array',
+          description: 'Output configurations specifying which block outputs to display in chat',
+          items: {
+            type: 'object',
+            properties: {
+              blockId: {
+                type: 'string',
+                description: 'The block UUID',
+              },
+              path: {
+                type: 'string',
+                description: "The output path (e.g. 'response', 'response.content')",
+              },
+            },
+            required: ['blockId', 'path'],
+          },
+        },
+        password: {
+          type: 'string',
+          description: 'Password for password-protected chats',
+        },
+        title: {
+          type: 'string',
+          description: 'Display title for the chat interface',
+        },
+        welcomeMessage: {
+          type: 'string',
+          description: 'Welcome message shown to users',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to deploy (required in workspace context)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  deploy_mcp: {
+    parameters: {
+      type: 'object',
+      properties: {
+        parameterDescriptions: {
+          type: 'array',
+          description: 'Array of parameter descriptions for the tool',
+          items: {
+            type: 'object',
+            properties: {
+              description: {
+                type: 'string',
+                description: 'Parameter description',
+              },
+              name: {
+                type: 'string',
+                description: 'Parameter name',
+              },
+            },
+            required: ['name', 'description'],
+          },
+        },
+        serverId: {
+          type: 'string',
+          description: 'Required: server ID from list_workspace_mcp_servers',
+        },
+        toolDescription: {
+          type: 'string',
+          description: 'Description for the MCP tool',
+        },
+        toolName: {
+          type: 'string',
+          description: 'Name for the MCP tool (defaults to workflow name)',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID (defaults to active workflow)',
+        },
+      },
+      required: ['serverId'],
+    },
+    resultSchema: undefined,
+  },
+  download_to_workspace_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fileName: {
+          type: 'string',
+          description:
+            'Optional workspace file name to save as. If omitted, the name is inferred from the response or URL.',
+        },
+        url: {
+          type: 'string',
+          description:
+            'Direct URL of the file to download, such as an image CDN URL ending in .png or .jpg',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  edit_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operations: {
+          type: 'array',
+          description: 'Array of edit operations',
+          items: {
+            type: 'object',
+            properties: {
+              block_id: {
+                type: 'string',
+                description:
+                  'Block ID for the operation. For add operations, this will be the desired ID for the new block.',
+              },
+              operation_type: {
+                type: 'string',
+                description: 'Type of operation to perform',
+                enum: ['add', 'edit', 'delete', 'insert_into_subflow', 'extract_from_subflow'],
+              },
+              params: {
+                type: 'object',
+                description:
+                  'Parameters for the operation. \nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "gpt-4o"}}\nFor delete: {} (empty object)',
+              },
+            },
+            required: ['operation_type', 'block_id', 'params'],
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to edit. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['operations'],
+    },
+    resultSchema: undefined,
+  },
+  file: {
+    parameters: {
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  function_execute: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with access to pre-installed CLI tools and workspace env vars as $VAR_NAME.',
+        },
+        inputFiles: {
+          type: 'array',
+          description:
+            'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}. Example: ["wf_123"]',
+          items: {
+            type: 'string',
+          },
+        },
+        inputTables: {
+          type: 'array',
+          description:
+            'Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Example: ["tbl_abc123"]',
+          items: {
+            type: 'string',
+          },
+        },
+        language: {
+          type: 'string',
+          description: 'Execution language.',
+          enum: ['javascript', 'python', 'shell'],
+        },
+        outputFormat: {
+          type: 'string',
+          description:
+            'Format for outputPath. Determines how the code result is serialized. If omitted, inferred from outputPath file extension.',
+          enum: ['json', 'csv', 'txt', 'md', 'html'],
+        },
+        outputMimeType: {
+          type: 'string',
+          description:
+            'MIME type for outputSandboxPath export. Required for binary files: image/png, image/jpeg, application/pdf, etc. Omit for text files.',
+        },
+        outputPath: {
+          type: 'string',
+          description:
+            'Pipe output directly to a NEW workspace file instead of returning in context. ALWAYS use this instead of a separate workspace_file write call. Use a flat path like "files/result.json" — nested paths are not supported.',
+        },
+        outputSandboxPath: {
+          type: 'string',
+          description:
+            'Path to a file created inside the sandbox that should be exported to the workspace. Use together with outputPath.',
+        },
+        outputTable: {
+          type: 'string',
+          description:
+            'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
+        },
+      },
+      required: ['code'],
+    },
+    resultSchema: undefined,
+  },
+  generate_api_key: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description:
+            "A descriptive name for the API key (e.g., 'production-key', 'dev-testing').",
+        },
+        workspaceId: {
+          type: 'string',
+          description: "Optional workspace ID. Defaults to user's default workspace.",
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  generate_image: {
+    parameters: {
+      type: 'object',
+      properties: {
+        aspectRatio: {
+          type: 'string',
+          description: 'Aspect ratio for the generated image.',
+          enum: ['1:1', '16:9', '9:16', '4:3', '3:4'],
+        },
+        fileName: {
+          type: 'string',
+          description:
+            'Output file name. Defaults to "generated-image.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+        },
+        overwriteFileId: {
+          type: 'string',
+          description:
+            'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update or redo a previously generated image. The file ID is returned by previous generate_image or generate_visualization calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+        },
+        prompt: {
+          type: 'string',
+          description:
+            'Detailed text description of the image to generate, or editing instructions when used with editFileId.',
+        },
+        referenceFileIds: {
+          type: 'array',
+          description:
+            'File IDs of workspace images to include as context for the generation. All images are sent alongside the prompt. Use for: editing a single image (1 file), compositing multiple images together (2+ files), style transfer, face swapping, etc. Order matters — list the primary/base image first.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['prompt'],
+    },
+    resultSchema: undefined,
+  },
+  generate_visualization: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            "Python code that generates a visualization using matplotlib. MUST call plt.savefig('/home/user/output.png', dpi=150, bbox_inches='tight') to produce output.",
+        },
+        fileName: {
+          type: 'string',
+          description:
+            'Output file name. Defaults to "chart.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+        },
+        inputFiles: {
+          type: 'array',
+          description:
+            'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}.',
+          items: {
+            type: 'string',
+          },
+        },
+        inputTables: {
+          type: 'array',
+          description:
+            "Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Read with pandas: pd.read_csv('/home/user/tables/tbl_xxx.csv')",
+          items: {
+            type: 'string',
+          },
+        },
+        overwriteFileId: {
+          type: 'string',
+          description:
+            'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update or redo a previously generated chart. The file ID is returned by previous generate_visualization or generate_image calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+        },
+      },
+      required: ['code'],
+    },
+    resultSchema: undefined,
+  },
+  get_block_outputs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockIds: {
+          type: 'array',
+          description:
+            'Optional array of block UUIDs. If provided, returns outputs only for those blocks. If not provided, returns outputs for all blocks in the workflow.',
+          items: {
+            type: 'string',
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  get_block_upstream_references: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockIds: {
+          type: 'array',
+          description:
+            'Required array of block UUIDs (minimum 1). Returns what each block can reference based on its position in the workflow graph.',
+          items: {
+            type: 'string',
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['blockIds'],
+    },
+    resultSchema: undefined,
+  },
+  get_deployed_workflow_state: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  get_deployment_version: {
+    parameters: {
+      type: 'object',
+      properties: {
+        version: {
+          type: 'number',
+          description: 'The deployment version number',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID',
+        },
+      },
+      required: ['workflowId', 'version'],
+    },
+    resultSchema: undefined,
+  },
+  get_execution_summary: {
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Max number of executions to return (default: 10, max: 20).',
+        },
+        status: {
+          type: 'string',
+          description: "Filter by status: 'success', 'error', or 'all' (default: 'all').",
+          enum: ['success', 'error', 'all'],
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If omitted, returns executions across all workflows in the workspace.',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Workspace ID to scope executions to.',
+        },
+      },
+      required: ['workspaceId'],
+    },
+    resultSchema: undefined,
+  },
+  get_job_logs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        executionId: {
+          type: 'string',
+          description: 'Optional execution ID for a specific run.',
+        },
+        includeDetails: {
+          type: 'boolean',
+          description: 'Include tool calls, outputs, and cost details.',
+        },
+        jobId: {
+          type: 'string',
+          description: 'The job (schedule) ID to get logs for.',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max number of entries (default: 3, max: 5)',
+        },
+      },
+      required: ['jobId'],
+    },
+    resultSchema: undefined,
+  },
+  get_page_contents: {
+    parameters: {
+      type: 'object',
+      properties: {
+        include_highlights: {
+          type: 'boolean',
+          description: 'Include key highlights (default false)',
+        },
+        include_summary: {
+          type: 'boolean',
+          description: 'Include AI-generated summary (default false)',
+        },
+        include_text: {
+          type: 'boolean',
+          description: 'Include full page text (default true)',
+        },
+        urls: {
+          type: 'array',
+          description: 'URLs to get content from (max 10)',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['urls'],
+    },
+    resultSchema: undefined,
+  },
+  get_platform_actions: {
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+    resultSchema: undefined,
+  },
+  get_workflow_data: {
+    parameters: {
+      type: 'object',
+      properties: {
+        data_type: {
+          type: 'string',
+          description: 'The type of workflow data to retrieve',
+          enum: ['global_variables', 'custom_tools', 'mcp_tools', 'files'],
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['data_type'],
+    },
+    resultSchema: undefined,
+  },
+  get_workflow_logs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        executionId: {
+          type: 'string',
+          description:
+            'Optional execution ID to get logs for a specific execution. Use with get_execution_summary to find execution IDs first.',
+        },
+        includeDetails: {
+          type: 'boolean',
+          description: 'Include detailed info',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max number of entries (hard limit: 3)',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  glob: {
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: {
+          type: 'string',
+          description:
+            'Glob pattern to match file paths. Supports * (any segment) and ** (any depth).',
+        },
+      },
+      required: ['pattern'],
+    },
+    resultSchema: undefined,
+  },
+  grep: {
+    parameters: {
+      type: 'object',
+      properties: {
+        context: {
+          type: 'number',
+          description:
+            "Number of lines to show before and after each match. Only applies to output_mode 'content'.",
+        },
+        ignoreCase: {
+          type: 'boolean',
+          description: 'Case insensitive search (default false).',
+        },
+        lineNumbers: {
+          type: 'boolean',
+          description:
+            "Include line numbers in output (default true). Only applies to output_mode 'content'.",
+        },
+        maxResults: {
+          type: 'number',
+          description: 'Maximum number of matches to return (default 50).',
+        },
+        output_mode: {
+          type: 'string',
+          description:
+            "Output mode: 'content' shows matching lines (default), 'files_with_matches' shows only file paths, 'count' shows match counts per file.",
+          enum: ['content', 'files_with_matches', 'count'],
+        },
+        path: {
+          type: 'string',
+          description:
+            "Optional path prefix to scope the search (e.g. 'workflows/', 'environment/', 'internal/', 'components/blocks/').",
+        },
+        pattern: {
+          type: 'string',
+          description: 'Regex pattern to search for in file contents.',
+        },
+      },
+      required: ['pattern'],
+    },
+    resultSchema: undefined,
+  },
+  job: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What job action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  knowledge: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What knowledge base action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  knowledge_base: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            apiKey: {
+              type: 'string',
+              description:
+                'API key for API-key-based connectors (required when connector auth mode is apiKey)',
+            },
+            chunkingConfig: {
+              type: 'object',
+              description: "Chunking configuration (optional for 'create')",
+              properties: {
+                maxSize: {
+                  type: 'number',
+                  description: 'Maximum chunk size (100-4000, default: 1024)',
+                  default: 1024,
+                },
+                minSize: {
+                  type: 'number',
+                  description: 'Minimum chunk size (1-2000, default: 1)',
+                  default: 1,
+                },
+                overlap: {
+                  type: 'number',
+                  description: 'Overlap between chunks (0-500, default: 200)',
+                  default: 200,
+                },
+              },
+            },
+            connectorId: {
+              type: 'string',
+              description:
+                'Connector ID (required for update_connector, delete_connector, sync_connector)',
+            },
+            connectorStatus: {
+              type: 'string',
+              description: 'Connector status (optional for update_connector)',
+              enum: ['active', 'paused'],
+            },
+            connectorType: {
+              type: 'string',
+              description:
+                "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
+            },
+            credentialId: {
+              type: 'string',
+              description:
+                'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
+            },
+            description: {
+              type: 'string',
+              description: "Description of the knowledge base (optional for 'create')",
+            },
+            disabledTagIds: {
+              type: 'array',
+              description:
+                'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
+            },
+            documentId: {
+              type: 'string',
+              description: 'Document ID (required for delete_document, update_document)',
+            },
+            enabled: {
+              type: 'boolean',
+              description: 'Enable/disable a document (optional for update_document)',
+            },
+            fileId: {
+              type: 'string',
+              description:
+                'Canonical workspace file ID to add as a document (preferred for add_file). Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+            },
+            filePath: {
+              type: 'string',
+              description: 'Legacy workspace file reference for add_file. Prefer fileId.',
+            },
+            filename: {
+              type: 'string',
+              description: 'New filename for a document (optional for update_document)',
+            },
+            knowledgeBaseId: {
+              type: 'string',
+              description:
+                'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
+            },
+            name: {
+              type: 'string',
+              description: "Name of the knowledge base (required for 'create')",
+            },
+            query: {
+              type: 'string',
+              description: "Search query text (required for 'query')",
+            },
+            sourceConfig: {
+              type: 'object',
+              description:
+                'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
+            },
+            syncIntervalMinutes: {
+              type: 'number',
+              description:
+                'Sync interval in minutes: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
+              default: 1440,
+            },
+            tagDefinitionId: {
+              type: 'string',
+              description: 'Tag definition ID (required for update_tag, delete_tag)',
+            },
+            tagDisplayName: {
+              type: 'string',
+              description:
+                'Display name for the tag (required for create_tag, optional for update_tag)',
+            },
+            tagFieldType: {
+              type: 'string',
+              description:
+                'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
+              enum: ['text', 'number', 'date', 'boolean'],
+            },
+            topK: {
+              type: 'number',
+              description: 'Number of results to return (1-50, default: 5)',
+              default: 5,
+            },
+            workspaceId: {
+              type: 'string',
+              description: "Workspace ID (required for 'create', optional filter for 'list')",
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: [
+            'create',
+            'get',
+            'query',
+            'add_file',
+            'update',
+            'delete',
+            'delete_document',
+            'update_document',
+            'list_tags',
+            'create_tag',
+            'update_tag',
+            'delete_tag',
+            'get_tag_usage',
+            'add_connector',
+            'update_connector',
+            'delete_connector',
+            'sync_connector',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  list_folders: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workspaceId: {
+          type: 'string',
+          description: 'Optional workspace ID to list folders for.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  list_user_workspaces: {
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+    resultSchema: undefined,
+  },
+  list_workspace_mcp_servers: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workspaceId: {
+          type: 'string',
+          description: 'Workspace ID (defaults to current workspace)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  manage_credential: {
+    parameters: {
+      type: 'object',
+      properties: {
+        credentialId: {
+          type: 'string',
+          description: 'The credential ID (from environment/credentials.json)',
+        },
+        displayName: {
+          type: 'string',
+          description: 'New display name (required for rename)',
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: ['rename', 'delete'],
+        },
+      },
+      required: ['operation', 'credentialId'],
+    },
+    resultSchema: undefined,
+  },
+  manage_custom_tool: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            'The JavaScript code that executes when the tool is called (required for add). Parameters from schema are available as variables. Function body only - no signature or wrapping braces.',
+        },
+        operation: {
+          type: 'string',
+          description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+          enum: ['add', 'edit', 'delete', 'list'],
+        },
+        schema: {
+          type: 'object',
+          description: 'The tool schema in OpenAI function calling format (required for add).',
+          properties: {
+            function: {
+              type: 'object',
+              description: 'The function definition',
+              properties: {
+                description: {
+                  type: 'string',
+                  description: 'What the function does',
+                },
+                name: {
+                  type: 'string',
+                  description: 'The function name (camelCase)',
+                },
+                parameters: {
+                  type: 'object',
+                  description: 'The function parameters schema',
+                  properties: {
+                    properties: {
+                      type: 'object',
+                      description: 'Parameter definitions as key-value pairs',
+                    },
+                    required: {
+                      type: 'array',
+                      description: 'Array of required parameter names',
+                      items: {
+                        type: 'string',
+                      },
+                    },
+                    type: {
+                      type: 'string',
+                      description: "Must be 'object'",
+                    },
+                  },
+                  required: ['type', 'properties'],
+                },
+              },
+              required: ['name', 'parameters'],
+            },
+            type: {
+              type: 'string',
+              description: "Must be 'function'",
+            },
+          },
+          required: ['type', 'function'],
+        },
+        toolId: {
+          type: 'string',
+          description:
+            "The ID of the custom tool (required for edit/delete). Must be the exact toolId from the get_workflow_data custom tool response - do not guess or construct it. DO NOT PROVIDE THE TOOL ID IF THE OPERATION IS 'ADD'.",
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_job: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description:
+            'Operation-specific arguments. For create: {title, prompt, cron?, time?, timezone?, lifecycle?, successCondition?, maxRuns?}. For get/delete: {jobId}. For update: {jobId, title?, prompt?, cron?, timezone?, status?, lifecycle?, successCondition?, maxRuns?}. For list: no args needed.',
+          properties: {
+            cron: {
+              type: 'string',
+              description: 'Cron expression for recurring jobs',
+            },
+            jobId: {
+              type: 'string',
+              description: 'Job ID (required for get, update, delete)',
+            },
+            lifecycle: {
+              type: 'string',
+              description:
+                "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called.",
+            },
+            maxRuns: {
+              type: 'integer',
+              description: 'Max executions before auto-completing. Safety limit.',
+            },
+            prompt: {
+              type: 'string',
+              description: 'The prompt to execute when the job fires',
+            },
+            status: {
+              type: 'string',
+              description: 'Job status: active, paused',
+            },
+            successCondition: {
+              type: 'string',
+              description:
+                'What must happen for the job to be considered complete (until_complete lifecycle).',
+            },
+            time: {
+              type: 'string',
+              description: 'ISO 8601 datetime for one-time jobs or cron start time',
+            },
+            timezone: {
+              type: 'string',
+              description: 'IANA timezone (e.g. America/New_York). Defaults to UTC.',
+            },
+            title: {
+              type: 'string',
+              description: "Short descriptive title for the job (e.g. 'Email Poller')",
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform: create, list, get, update, delete',
+          enum: ['create', 'list', 'get', 'update', 'delete'],
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_mcp_tool: {
+    parameters: {
+      type: 'object',
+      properties: {
+        config: {
+          type: 'object',
+          description: 'Required for add and edit. The MCP server configuration.',
+          properties: {
+            enabled: {
+              type: 'boolean',
+              description: 'Whether the server is enabled (default: true)',
+            },
+            headers: {
+              type: 'object',
+              description: 'Optional HTTP headers to send with requests (key-value pairs)',
+            },
+            name: {
+              type: 'string',
+              description: 'Display name for the MCP server',
+            },
+            timeout: {
+              type: 'number',
+              description: 'Request timeout in milliseconds (default: 30000)',
+            },
+            transport: {
+              type: 'string',
+              description: "Transport protocol: 'streamable-http' or 'sse'",
+              enum: ['streamable-http', 'sse'],
+              default: 'streamable-http',
+            },
+            url: {
+              type: 'string',
+              description: 'The MCP server endpoint URL (required for add)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+          enum: ['add', 'edit', 'delete', 'list'],
+        },
+        serverId: {
+          type: 'string',
+          description:
+            "Required for edit and delete. The database ID of the MCP server. DO NOT PROVIDE if operation is 'add' or 'list'.",
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_skill: {
+    parameters: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Markdown instructions for the skill. Required for add, optional for edit.',
+        },
+        description: {
+          type: 'string',
+          description: 'Short description of the skill. Required for add, optional for edit.',
+        },
+        name: {
+          type: 'string',
+          description:
+            "Skill name in kebab-case (e.g. 'my-skill'). Required for add, optional for edit.",
+        },
+        operation: {
+          type: 'string',
+          description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+          enum: ['add', 'edit', 'delete', 'list'],
+        },
+        skillId: {
+          type: 'string',
+          description:
+            "The ID of the skill (required for edit/delete). Must be the exact ID from the VFS or list. DO NOT PROVIDE if operation is 'add' or 'list'.",
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  materialize_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fileName: {
+          type: 'string',
+          description: 'The name of the uploaded file to materialize (e.g. "report.pdf")',
+        },
+        knowledgeBaseId: {
+          type: 'string',
+          description:
+            'ID of an existing knowledge base to add the file to (only used with operation "knowledge_base"). If omitted, a new KB is created.',
+        },
+        operation: {
+          type: 'string',
+          description:
+            'What to do with the file. "save" promotes it to files/. "import" imports a workflow JSON. "table" converts CSV/TSV/JSON to a table. "knowledge_base" saves and adds to a KB. Defaults to "save".',
+          enum: ['save', 'import', 'table', 'knowledge_base'],
+          default: 'save',
+        },
+        tableName: {
+          type: 'string',
+          description:
+            'Custom name for the table (only used with operation "table"). Defaults to the file name without extension.',
+        },
+      },
+      required: ['fileName'],
+    },
+    resultSchema: undefined,
+  },
+  move_folder: {
+    parameters: {
+      type: 'object',
+      properties: {
+        folderId: {
+          type: 'string',
+          description: 'The folder ID to move.',
+        },
+        parentId: {
+          type: 'string',
+          description:
+            'Target parent folder ID. Omit or pass empty string to move to workspace root.',
+        },
+      },
+      required: ['folderId'],
+    },
+    resultSchema: undefined,
+  },
+  move_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        folderId: {
+          type: 'string',
+          description: 'Target folder ID. Omit or pass empty string to move to workspace root.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID to move.',
+        },
+      },
+      required: ['workflowId'],
+    },
+    resultSchema: undefined,
+  },
+  oauth_get_auth_link: {
+    parameters: {
+      type: 'object',
+      properties: {
+        providerName: {
+          type: 'string',
+          description:
+            "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar', 'GitHub')",
+        },
+      },
+      required: ['providerName'],
+    },
+    resultSchema: undefined,
+  },
+  oauth_request_access: {
+    parameters: {
+      type: 'object',
+      properties: {
+        providerName: {
+          type: 'string',
+          description:
+            "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar')",
+        },
+      },
+      required: ['providerName'],
+    },
+    resultSchema: undefined,
+  },
+  open_resource: {
+    parameters: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'The resource ID to open.',
+        },
+        type: {
+          type: 'string',
+          description: 'The resource type to open.',
+          enum: ['workflow', 'table', 'knowledgebase', 'file'],
+        },
+      },
+      required: ['type', 'id'],
+    },
+    resultSchema: undefined,
+  },
+  read: {
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Maximum number of lines to read.',
+        },
+        offset: {
+          type: 'number',
+          description: 'Line offset to start reading from (0-indexed).',
+        },
+        outputTable: {
+          type: 'string',
+          description:
+            'Table ID to import the file contents into (CSV/JSON). All existing rows are replaced. Example: "tbl_abc123"',
+        },
+        path: {
+          type: 'string',
+          description: "Path to the file to read (e.g. 'workflows/My Workflow/state.json').",
+        },
+      },
+      required: ['path'],
+    },
+    resultSchema: undefined,
+  },
+  redeploy: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to redeploy (required in workspace context)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  rename_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'The new name for the workflow.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID to rename.',
+        },
+      },
+      required: ['workflowId', 'name'],
+    },
+    resultSchema: undefined,
+  },
+  research: {
+    parameters: {
+      properties: {
+        topic: {
+          description: 'The topic to research.',
+          type: 'string',
+        },
+      },
+      required: ['topic'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  respond: {
+    parameters: {
+      additionalProperties: true,
+      properties: {
+        output: {
+          description:
+            'The result — facts, status, VFS paths to persisted data, whatever the caller needs to act on.',
+          type: 'string',
+        },
+        success: {
+          description: 'Whether the task completed successfully',
+          type: 'boolean',
+        },
+        type: {
+          description: 'Optional logical result type override',
+          type: 'string',
+        },
+      },
+      required: ['output', 'success'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  revert_to_version: {
+    parameters: {
+      type: 'object',
+      properties: {
+        version: {
+          type: 'number',
+          description: 'The deployment version number to revert to',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID',
+        },
+      },
+      required: ['workflowId', 'version'],
+    },
+    resultSchema: undefined,
+  },
+  run: {
+    parameters: {
+      properties: {
+        context: {
+          description: 'Pre-gathered context: workflow state, block IDs, input requirements.',
+          type: 'string',
+        },
+        request: {
+          description: 'What to run or what logs to check.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  run_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockId: {
+          type: 'string',
+          description: 'The block ID to run in isolation.',
+        },
+        executionId: {
+          type: 'string',
+          description:
+            'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['blockId'],
+    },
+    resultSchema: undefined,
+  },
+  run_from_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        executionId: {
+          type: 'string',
+          description:
+            'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+        },
+        startBlockId: {
+          type: 'string',
+          description: 'The block ID to start execution from.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['startBlockId'],
+    },
+    resultSchema: undefined,
+  },
+  run_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['workflow_input'],
+    },
+    resultSchema: undefined,
+  },
+  run_workflow_until_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        stopAfterBlockId: {
+          type: 'string',
+          description: 'The block ID to stop after. Execution halts once this block completes.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['stopAfterBlockId'],
+    },
+    resultSchema: undefined,
+  },
+  scrape_page: {
+    parameters: {
+      type: 'object',
+      properties: {
+        include_links: {
+          type: 'boolean',
+          description: 'Extract all links from the page (default false)',
+        },
+        url: {
+          type: 'string',
+          description: 'The URL to scrape (must include https://)',
+        },
+        wait_for: {
+          type: 'string',
+          description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  search_documentation: {
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'The search query',
+        },
+        topK: {
+          type: 'number',
+          description: 'Number of results (max 10)',
+        },
+      },
+      required: ['query'],
+    },
+    resultSchema: undefined,
+  },
+  search_library_docs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        library_name: {
+          type: 'string',
+          description: "Name of the library to search for (e.g., 'nextjs', 'stripe', 'langchain')",
+        },
+        query: {
+          type: 'string',
+          description: 'The question or topic to find documentation for - be specific',
+        },
+        version: {
+          type: 'string',
+          description: "Specific version (optional, e.g., '14', 'v2')",
+        },
+      },
+      required: ['library_name', 'query'],
+    },
+    resultSchema: undefined,
+  },
+  search_online: {
+    parameters: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description: 'Filter by category',
+          enum: [
+            'news',
+            'tweet',
+            'github',
+            'paper',
+            'company',
+            'research paper',
+            'linkedin profile',
+            'pdf',
+            'personal site',
+          ],
+        },
+        include_text: {
+          type: 'boolean',
+          description: 'Include page text content (default true)',
+        },
+        num_results: {
+          type: 'number',
+          description: 'Number of results (default 10, max 25)',
+        },
+        query: {
+          type: 'string',
+          description: 'Natural language search query',
+        },
+      },
+      required: ['query'],
+    },
+    resultSchema: undefined,
+  },
+  search_patterns: {
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'integer',
+          description: 'Maximum number of unique pattern examples to return (defaults to 3).',
+        },
+        queries: {
+          type: 'array',
+          description:
+            'Up to 3 descriptive strings explaining the workflow pattern(s) you need. Focus on intent and desired outcomes.',
+          items: {
+            type: 'string',
+            description: 'Example: "how to automate wealthbox meeting notes into follow-up tasks"',
+          },
+        },
+      },
+      required: ['queries'],
+    },
+    resultSchema: undefined,
+  },
+  set_environment_variables: {
+    parameters: {
+      type: 'object',
+      properties: {
+        variables: {
+          type: 'array',
+          description: 'List of env vars to set',
+          items: {
+            type: 'object',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Variable name',
+              },
+              value: {
+                type: 'string',
+                description: 'Variable value',
+              },
+            },
+            required: ['name', 'value'],
+          },
+        },
+      },
+      required: ['variables'],
+    },
+    resultSchema: undefined,
+  },
+  set_global_workflow_variables: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operations: {
+          type: 'array',
+          description: 'List of operations to apply',
+          items: {
+            type: 'object',
+            properties: {
+              name: {
+                type: 'string',
+              },
+              operation: {
+                type: 'string',
+                enum: ['add', 'delete', 'edit'],
+              },
+              type: {
+                type: 'string',
+                enum: ['plain', 'number', 'boolean', 'array', 'object'],
+              },
+              value: {
+                type: 'string',
+              },
+            },
+            required: ['operation', 'name', 'type', 'value'],
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['operations'],
+    },
+    resultSchema: undefined,
+  },
+  superagent: {
+    parameters: {
+      properties: {
+        task: {
+          description:
+            "A single sentence — the agent has full conversation context. Do NOT pre-read credentials or look up configs. Example: 'send the email we discussed' or 'check my calendar for tomorrow'.",
+          type: 'string',
+        },
+      },
+      required: ['task'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  table: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What table action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  tool_search_tool_regex: {
+    parameters: {
+      properties: {
+        case_insensitive: {
+          description: 'Whether the regex should be case-insensitive (default true).',
+          type: 'boolean',
+        },
+        max_results: {
+          description: 'Maximum number of tools to return (optional).',
+          type: 'integer',
+        },
+        pattern: {
+          description: 'Regular expression to match tool names or descriptions.',
+          type: 'string',
+        },
+      },
+      required: ['pattern'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  update_job_history: {
+    parameters: {
+      type: 'object',
+      properties: {
+        jobId: {
+          type: 'string',
+          description: 'The job ID.',
+        },
+        summary: {
+          type: 'string',
+          description:
+            "A concise summary of what was done this run (e.g., 'Sent follow-up emails to 3 leads: Alice, Bob, Carol').",
+        },
+      },
+      required: ['jobId', 'summary'],
+    },
+    resultSchema: undefined,
+  },
+  update_workspace_mcp_server: {
+    parameters: {
+      type: 'object',
+      properties: {
+        description: {
+          type: 'string',
+          description: 'New description for the server',
+        },
+        isPublic: {
+          type: 'boolean',
+          description: 'Whether the server is publicly accessible',
+        },
+        name: {
+          type: 'string',
+          description: 'New name for the server',
+        },
+        serverId: {
+          type: 'string',
+          description: 'Required: the MCP server ID to update',
+        },
+      },
+      required: ['serverId'],
+    },
+    resultSchema: undefined,
+  },
+  user_memory: {
+    parameters: {
+      type: 'object',
+      properties: {
+        confidence: {
+          type: 'number',
+          description: 'Confidence level 0-1 (default 1.0 for explicit, 0.8 for inferred)',
+        },
+        correct_value: {
+          type: 'string',
+          description: "The correct value to replace the wrong one (for 'correct' operation)",
+        },
+        key: {
+          type: 'string',
+          description: "Unique key for the memory (e.g., 'preferred_model', 'slack_credential')",
+        },
+        limit: {
+          type: 'number',
+          description: 'Number of results for search (default 10)',
+        },
+        memory_type: {
+          type: 'string',
+          description: "Type of memory: 'preference', 'entity', 'history', or 'correction'",
+          enum: ['preference', 'entity', 'history', 'correction'],
+        },
+        operation: {
+          type: 'string',
+          description: "Operation: 'add', 'search', 'delete', 'correct', or 'list'",
+          enum: ['add', 'search', 'delete', 'correct', 'list'],
+        },
+        query: {
+          type: 'string',
+          description: 'Search query to find relevant memories',
+        },
+        source: {
+          type: 'string',
+          description: "Source: 'explicit' (user told you) or 'inferred' (you observed)",
+          enum: ['explicit', 'inferred'],
+        },
+        value: {
+          type: 'string',
+          description: 'Value to remember',
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  user_table: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            column: {
+              type: 'object',
+              description: 'Column definition for add_column: { name, type, unique?, position? }',
+            },
+            columnName: {
+              type: 'string',
+              description:
+                'Column name (required for rename_column, update_column; use columnNames array for batch delete_column)',
+            },
+            columnNames: {
+              type: 'array',
+              description:
+                'Array of column names to delete at once (for delete_column). Preferred over columnName when deleting multiple columns.',
+            },
+            data: {
+              type: 'object',
+              description: 'Row data as key-value pairs (required for insert_row, update_row)',
+            },
+            description: {
+              type: 'string',
+              description: "Table description (optional for 'create')",
+            },
+            fileId: {
+              type: 'string',
+              description:
+                'Canonical workspace file ID for create_from_file/import_file. Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+            },
+            filePath: {
+              type: 'string',
+              description:
+                'Legacy workspace file reference for create_from_file/import_file. Prefer fileId.',
+            },
+            filter: {
+              type: 'object',
+              description:
+                'MongoDB-style filter for query_rows, update_rows_by_filter, delete_rows_by_filter',
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum rows to return or affect (optional, default 100)',
+            },
+            name: {
+              type: 'string',
+              description: "Table name (required for 'create')",
+            },
+            newName: {
+              type: 'string',
+              description: 'New column name (required for rename_column)',
+            },
+            newType: {
+              type: 'string',
+              description:
+                'New column type (optional for update_column). Types: string, number, boolean, date, json',
+            },
+            offset: {
+              type: 'number',
+              description: 'Number of rows to skip (optional for query_rows, default 0)',
+            },
+            outputFormat: {
+              type: 'string',
+              description:
+                'Explicit format override for outputPath. Usually unnecessary — the file extension determines the format automatically. Only use this to force a different format than what the extension implies.',
+              enum: ['json', 'csv', 'txt', 'md', 'html'],
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Pipe query_rows results directly to a NEW workspace file. The format is auto-inferred from the file extension: .csv → CSV, .json → JSON, .md → Markdown, etc. Use .csv for tabular exports. Use a flat path like "files/export.csv" — nested paths are not supported.',
+            },
+            rowId: {
+              type: 'string',
+              description: 'Row ID (required for get_row, update_row, delete_row)',
+            },
+            rowIds: {
+              type: 'array',
+              description: 'Array of row IDs to delete (for batch_delete_rows)',
+            },
+            rows: {
+              type: 'array',
+              description: 'Array of row data objects (required for batch_insert_rows)',
+            },
+            schema: {
+              type: 'object',
+              description:
+                "Table schema with columns array (required for 'create'). Each column: { name, type, unique? }",
+            },
+            sort: {
+              type: 'object',
+              description:
+                "Sort specification as { field: 'asc' | 'desc' } (optional for query_rows)",
+            },
+            tableId: {
+              type: 'string',
+              description: "Table ID (required for most operations except 'create')",
+            },
+            unique: {
+              type: 'boolean',
+              description: 'Set column unique constraint (optional for update_column)',
+            },
+            updates: {
+              type: 'array',
+              description:
+                'Array of per-row updates: [{ rowId, data: { col: val } }] (for batch_update_rows)',
+            },
+            values: {
+              type: 'object',
+              description:
+                'Map of rowId to value for single-column batch update: { "rowId1": val1, "rowId2": val2 } (for batch_update_rows with columnName)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: [
+            'create',
+            'create_from_file',
+            'import_file',
+            'get',
+            'get_schema',
+            'delete',
+            'insert_row',
+            'batch_insert_rows',
+            'get_row',
+            'query_rows',
+            'update_row',
+            'delete_row',
+            'update_rows_by_filter',
+            'delete_rows_by_filter',
+            'batch_update_rows',
+            'batch_delete_rows',
+            'add_column',
+            'rename_column',
+            'delete_column',
+            'update_column',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  workflow: {
+    parameters: {
+      properties: {
+        request: {
+          description:
+            "A single sentence — the agent has full conversation context and VFS access. Do NOT look up IDs or pre-read data; the workflow agent does its own research. Example: 'move all the return letter workflows into a folder called Letters'.",
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  workspace_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operation: {
+          type: 'string',
+          description: 'The file operation to perform.',
+          enum: ['create', 'append', 'update', 'patch', 'rename', 'delete'],
+        },
+        target: {
+          type: 'object',
+          description:
+            'Explicit file target. Use kind=new_file + fileName for create. Use kind=file_id + fileId for append, update, patch, rename, and delete. Emit target keys in this order: kind, fileId, fileName.',
+          properties: {
+            kind: {
+              type: 'string',
+              description: 'How the file target is identified.',
+              enum: ['new_file', 'file_id'],
+            },
+            fileId: {
+              type: 'string',
+              description:
+                'Canonical existing workspace file ID. Required when target.kind=file_id.',
+            },
+            fileName: {
+              type: 'string',
+              description:
+                'Plain workspace filename including extension, e.g. "main.py" or "report.docx". Required when target.kind=new_file.',
+            },
+          },
+          required: ['kind'],
+        },
+        title: {
+          type: 'string',
+          description:
+            'Optional short UI label for create/append chunks, e.g. "Chapter 1" or "Slide 3".',
+        },
+        contentType: {
+          type: 'string',
+          description:
+            'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
+          enum: [
+            'text/markdown',
+            'text/html',
+            'text/plain',
+            'application/json',
+            'text/csv',
+            'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'application/pdf',
+          ],
+        },
+        edit: {
+          type: 'object',
+          description:
+            'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. Emit edit keys in this order: strategy, search, replace, replaceAll, mode, occurrence, before_anchor, after_anchor, anchor, start_anchor, end_anchor, content.',
+          properties: {
+            strategy: {
+              type: 'string',
+              description: 'Patch strategy.',
+              enum: ['search_replace', 'anchored'],
+            },
+            search: {
+              type: 'string',
+              description:
+                'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
+            },
+            replace: {
+              type: 'string',
+              description: 'Replacement text when strategy=search_replace.',
+            },
+            replaceAll: {
+              type: 'boolean',
+              description:
+                'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
+            },
+            mode: {
+              type: 'string',
+              description: 'Anchored edit mode when strategy=anchored.',
+              enum: ['replace_between', 'insert_after', 'delete_between'],
+            },
+            occurrence: {
+              type: 'number',
+              description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
+            },
+            before_anchor: {
+              type: 'string',
+              description:
+                'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
+            },
+            after_anchor: {
+              type: 'string',
+              description:
+                'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
+            },
+            anchor: {
+              type: 'string',
+              description:
+                'Anchor line after which new content is inserted. Required for mode=insert_after.',
+            },
+            start_anchor: {
+              type: 'string',
+              description: 'First line to delete. Required for mode=delete_between.',
+            },
+            end_anchor: {
+              type: 'string',
+              description: 'First line to keep after deletion. Required for mode=delete_between.',
+            },
+            content: {
+              type: 'string',
+              description:
+                'Inserted or replacement content for anchored edits. Not used for delete_between.',
+            },
+          },
+        },
+        newName: {
+          type: 'string',
+          description:
+            'New file name for rename. Must be a plain workspace filename like "main.py".',
+        },
+        content: {
+          type: 'string',
+          description:
+            'File content for create, append, or update. For .pptx/.docx/.pdf this must be JavaScript source code for the corresponding generator runtime.',
+        },
+      },
+      required: ['operation', 'target'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description:
+            'Optional operation metadata such as file id, file name, size, and content type.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable summary of the outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the file operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+}
diff --git a/apps/sim/lib/copilot/logging.ts b/apps/sim/lib/copilot/logging.ts
deleted file mode 100644
index b1f0aa90435..00000000000
--- a/apps/sim/lib/copilot/logging.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-export interface CopilotLogContext {
-  requestId?: string
-  messageId?: string
-}
-
-/**
- * Appends copilot request identifiers to a log message.
- */
-export function appendCopilotLogContext(message: string, context: CopilotLogContext = {}): string {
-  const suffixParts: string[] = []
-
-  if (context.requestId) {
-    suffixParts.push(`requestId:${context.requestId}`)
-  }
-
-  if (context.messageId) {
-    suffixParts.push(`messageId:${context.messageId}`)
-  }
-
-  if (suffixParts.length === 0) {
-    return message
-  }
-
-  return `${message} [${suffixParts.join(' ')}]`
-}
diff --git a/apps/sim/lib/copilot/models.ts b/apps/sim/lib/copilot/models.ts
deleted file mode 100644
index f102de517f1..00000000000
--- a/apps/sim/lib/copilot/models.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-export type CopilotModelId = string
-
-export const COPILOT_MODES = ['ask', 'build', 'plan'] as const
-export type CopilotMode = (typeof COPILOT_MODES)[number]
-
-export const COPILOT_TRANSPORT_MODES = ['ask', 'agent', 'plan'] as const
-export type CopilotTransportMode = (typeof COPILOT_TRANSPORT_MODES)[number]
-
-export const COPILOT_REQUEST_MODES = ['ask', 'build', 'plan', 'agent'] as const
-export type CopilotRequestMode = (typeof COPILOT_REQUEST_MODES)[number]
diff --git a/apps/sim/lib/copilot/orchestrator/index.ts b/apps/sim/lib/copilot/orchestrator/index.ts
deleted file mode 100644
index 5893ce7bb4f..00000000000
--- a/apps/sim/lib/copilot/orchestrator/index.ts
+++ /dev/null
@@ -1,571 +0,0 @@
-import { createLogger } from '@sim/logger'
-import {
-  ASYNC_TOOL_STATUS,
-  inferDeliveredAsyncSuccess,
-  isDeliveredAsyncStatus,
-  isTerminalAsyncStatus,
-} from '@/lib/copilot/async-runs/lifecycle'
-import {
-  claimCompletedAsyncToolCall,
-  getAsyncToolCall,
-  getAsyncToolCalls,
-  markAsyncToolDelivered,
-  releaseCompletedAsyncToolClaim,
-  updateRunStatus,
-} from '@/lib/copilot/async-runs/repository'
-import { SIM_AGENT_API_URL, SIM_AGENT_VERSION } from '@/lib/copilot/constants'
-import {
-  isToolAvailableOnSimSide,
-  prepareExecutionContext,
-} from '@/lib/copilot/orchestrator/tool-executor'
-import {
-  type ExecutionContext,
-  isTerminalToolCallStatus,
-  type OrchestratorOptions,
-  type OrchestratorResult,
-  type SSEEvent,
-  type ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { env } from '@/lib/core/config/env'
-import { generateId } from '@/lib/core/utils/uuid'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { buildToolCallSummaries, createStreamingContext, runStreamLoop } from './stream/core'
-
-const logger = createLogger('CopilotOrchestrator')
-
-function didAsyncToolSucceed(input: {
-  durableStatus?: string | null
-  durableResult?: Record<string, unknown>
-  durableError?: string | null
-  toolStateStatus?: string | undefined
-}) {
-  const { durableStatus, durableResult, durableError, toolStateStatus } = input
-
-  if (durableStatus === ASYNC_TOOL_STATUS.completed) {
-    return true
-  }
-  if (durableStatus === ASYNC_TOOL_STATUS.failed || durableStatus === ASYNC_TOOL_STATUS.cancelled) {
-    return false
-  }
-
-  if (durableStatus === ASYNC_TOOL_STATUS.delivered) {
-    return inferDeliveredAsyncSuccess({
-      result: durableResult,
-      error: durableError,
-    })
-  }
-
-  if (toolStateStatus === 'success') return true
-  if (toolStateStatus === 'error' || toolStateStatus === 'cancelled') return false
-
-  return false
-}
-
-interface ReadyContinuationTool {
-  toolCallId: string
-  toolState?: ToolCallState
-  durableRow?: Awaited<ReturnType<typeof getAsyncToolCall>>
-  needsDurableClaim: boolean
-  alreadyClaimedByWorker: boolean
-}
-
-export interface OrchestrateStreamOptions extends OrchestratorOptions {
-  userId: string
-  workflowId?: string
-  workspaceId?: string
-  chatId?: string
-  executionId?: string
-  runId?: string
-  /** Go-side route to proxy to. Defaults to '/api/copilot'. */
-  goRoute?: string
-}
-
-export async function orchestrateCopilotStream(
-  requestPayload: Record<string, unknown>,
-  options: OrchestrateStreamOptions
-): Promise<OrchestratorResult> {
-  const {
-    userId,
-    workflowId,
-    workspaceId,
-    chatId,
-    executionId,
-    runId,
-    goRoute = '/api/copilot',
-  } = options
-
-  const userTimezone =
-    typeof requestPayload?.userTimezone === 'string' ? requestPayload.userTimezone : undefined
-
-  let execContext: ExecutionContext
-  if (workflowId) {
-    execContext = await prepareExecutionContext(userId, workflowId, chatId)
-  } else {
-    const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
-    execContext = {
-      userId,
-      workflowId: '',
-      workspaceId,
-      chatId,
-      decryptedEnvVars,
-    }
-  }
-  if (userTimezone) {
-    execContext.userTimezone = userTimezone
-  }
-  execContext.executionId = executionId
-  execContext.runId = runId
-  execContext.abortSignal = options.abortSignal
-  execContext.userStopSignal = options.userStopSignal
-
-  const payloadMsgId = requestPayload?.messageId
-  const messageId = typeof payloadMsgId === 'string' ? payloadMsgId : generateId()
-  execContext.messageId = messageId
-  const context = createStreamingContext({
-    chatId,
-    executionId,
-    runId,
-    messageId,
-  })
-  const continuationWorkerId = `sim-resume:${generateId()}`
-  const reqLogger = logger.withMetadata({ requestId: context.requestId, messageId })
-  let claimedToolCallIds: string[] = []
-  let claimedByWorkerId: string | null = null
-
-  reqLogger.info('Starting copilot orchestration', {
-    goRoute,
-    workflowId,
-    workspaceId,
-    chatId,
-    executionId,
-    runId,
-    hasUserTimezone: Boolean(userTimezone),
-  })
-
-  try {
-    let route = goRoute
-    let payload = requestPayload
-
-    const callerOnEvent = options.onEvent
-
-    for (;;) {
-      context.streamComplete = false
-
-      reqLogger.info('Starting orchestration loop iteration', {
-        route,
-        hasPendingAsyncContinuation: Boolean(context.awaitingAsyncContinuation),
-        claimedToolCallCount: claimedToolCallIds.length,
-      })
-
-      const loopOptions = {
-        ...options,
-        onEvent: async (event: SSEEvent) => {
-          if (event.type === 'done') {
-            const d = (event.data ?? {}) as Record<string, unknown>
-            const response = (d.response ?? {}) as Record<string, unknown>
-            if (response.async_pause) {
-              reqLogger.info('Detected async pause from copilot backend', {
-                route,
-                checkpointId:
-                  typeof (response.async_pause as Record<string, unknown>)?.checkpointId ===
-                  'string'
-                    ? (response.async_pause as Record<string, unknown>).checkpointId
-                    : undefined,
-              })
-              if (runId) {
-                await updateRunStatus(runId, 'paused_waiting_for_tool').catch(() => {})
-              }
-            }
-          }
-          await callerOnEvent?.(event)
-        },
-      }
-
-      await runStreamLoop(
-        `${SIM_AGENT_API_URL}${route}`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
-            'X-Client-Version': SIM_AGENT_VERSION,
-          },
-          body: JSON.stringify(payload),
-        },
-        context,
-        execContext,
-        loopOptions
-      )
-
-      reqLogger.info('Completed orchestration loop iteration', {
-        route,
-        streamComplete: context.streamComplete,
-        wasAborted: context.wasAborted,
-        hasAsyncContinuation: Boolean(context.awaitingAsyncContinuation),
-        errorCount: context.errors.length,
-      })
-
-      if (claimedToolCallIds.length > 0) {
-        reqLogger.info('Marking async tool calls as delivered', {
-          toolCallIds: claimedToolCallIds,
-        })
-        await Promise.all(
-          claimedToolCallIds.map((toolCallId) =>
-            markAsyncToolDelivered(toolCallId).catch(() => null)
-          )
-        )
-        claimedToolCallIds = []
-        claimedByWorkerId = null
-      }
-
-      if (options.abortSignal?.aborted || context.wasAborted) {
-        reqLogger.info('Stopping orchestration because request was aborted', {
-          pendingToolCallCount: Array.from(context.toolCalls.values()).filter(
-            (toolCall) => toolCall.status === 'pending' || toolCall.status === 'executing'
-          ).length,
-        })
-        for (const [toolCallId, toolCall] of context.toolCalls) {
-          if (toolCall.status === 'pending' || toolCall.status === 'executing') {
-            toolCall.status = 'cancelled'
-            toolCall.endTime = Date.now()
-            toolCall.error = 'Stopped by user'
-          }
-        }
-        context.awaitingAsyncContinuation = undefined
-        break
-      }
-
-      const continuation = context.awaitingAsyncContinuation
-      if (!continuation) {
-        reqLogger.info('No async continuation pending; finishing orchestration')
-        break
-      }
-
-      let resumeReady = false
-      let resumeRetries = 0
-      reqLogger.info('Processing async continuation', {
-        checkpointId: continuation.checkpointId,
-        runId: continuation.runId,
-        pendingToolCallIds: continuation.pendingToolCallIds,
-      })
-      for (;;) {
-        claimedToolCallIds = []
-        claimedByWorkerId = null
-        const resumeWorkerId = continuationWorkerId
-        const readyTools: ReadyContinuationTool[] = []
-        const localPendingPromises: Promise<unknown>[] = []
-        const missingToolCallIds: string[] = []
-
-        for (const toolCallId of continuation.pendingToolCallIds) {
-          const durableRow = await getAsyncToolCall(toolCallId).catch(() => null)
-          const localPendingPromise = context.pendingToolPromises.get(toolCallId)
-          const toolState = context.toolCalls.get(toolCallId)
-
-          if (localPendingPromise) {
-            localPendingPromises.push(localPendingPromise)
-            reqLogger.info('Waiting for local async tool completion before retrying resume claim', {
-              toolCallId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-            })
-            continue
-          }
-
-          if (durableRow && isTerminalAsyncStatus(durableRow.status)) {
-            if (durableRow.claimedBy && durableRow.claimedBy !== resumeWorkerId) {
-              missingToolCallIds.push(toolCallId)
-              reqLogger.warn(
-                'Async tool continuation is waiting on a claim held by another worker',
-                {
-                  toolCallId,
-                  runId: continuation.runId,
-                  workerId: resumeWorkerId,
-                  claimedBy: durableRow.claimedBy,
-                }
-              )
-              continue
-            }
-            readyTools.push({
-              toolCallId,
-              toolState,
-              durableRow,
-              needsDurableClaim: durableRow.claimedBy !== resumeWorkerId,
-              alreadyClaimedByWorker: durableRow.claimedBy === resumeWorkerId,
-            })
-            continue
-          }
-
-          if (
-            !durableRow &&
-            toolState &&
-            isTerminalToolCallStatus(toolState.status) &&
-            !isToolAvailableOnSimSide(toolState.name)
-          ) {
-            reqLogger.info('Including Go-handled tool in resume payload (no Sim-side row)', {
-              toolCallId,
-              toolName: toolState.name,
-              status: toolState.status,
-              runId: continuation.runId,
-            })
-            readyTools.push({
-              toolCallId,
-              toolState,
-              needsDurableClaim: false,
-              alreadyClaimedByWorker: false,
-            })
-            continue
-          }
-
-          reqLogger.warn('Skipping already-claimed or missing async tool resume', {
-            toolCallId,
-            runId: continuation.runId,
-            durableStatus: durableRow?.status,
-            toolStateStatus: toolState?.status,
-          })
-          missingToolCallIds.push(toolCallId)
-        }
-
-        if (localPendingPromises.length > 0) {
-          reqLogger.info('Waiting for local pending async tools before resuming continuation', {
-            checkpointId: continuation.checkpointId,
-            pendingPromiseCount: localPendingPromises.length,
-          })
-          await Promise.allSettled(localPendingPromises)
-          continue
-        }
-
-        if (missingToolCallIds.length > 0) {
-          if (resumeRetries < 3) {
-            resumeRetries++
-            reqLogger.info('Retrying async resume after some tool calls were not yet ready', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              retry: resumeRetries,
-              missingToolCallIds,
-            })
-            await new Promise((resolve) => setTimeout(resolve, 250 * resumeRetries))
-            continue
-          }
-          reqLogger.error(
-            'Async continuation failed because pending tool calls never became ready',
-            {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              missingToolCallIds,
-            }
-          )
-          throw new Error(
-            `Failed to resume async tool continuation: pending tool calls were not ready (${missingToolCallIds.join(', ')})`
-          )
-        }
-
-        if (readyTools.length === 0) {
-          if (resumeRetries < 3 && continuation.pendingToolCallIds.length > 0) {
-            resumeRetries++
-            reqLogger.info('Retrying async resume because no tool calls were ready yet', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              retry: resumeRetries,
-            })
-            await new Promise((resolve) => setTimeout(resolve, 250 * resumeRetries))
-            continue
-          }
-          reqLogger.error('Async continuation failed because no tool calls were ready', {
-            checkpointId: continuation.checkpointId,
-            runId: continuation.runId,
-            requestedToolCallIds: continuation.pendingToolCallIds,
-          })
-          throw new Error('Failed to resume async tool continuation: no tool calls were ready')
-        }
-
-        const claimCandidates = readyTools.filter((tool) => tool.needsDurableClaim)
-        const newlyClaimedToolCallIds: string[] = []
-        const claimFailures: string[] = []
-
-        for (const tool of claimCandidates) {
-          const claimed = await claimCompletedAsyncToolCall(tool.toolCallId, resumeWorkerId).catch(
-            () => null
-          )
-          if (!claimed) {
-            claimFailures.push(tool.toolCallId)
-            continue
-          }
-          newlyClaimedToolCallIds.push(tool.toolCallId)
-        }
-
-        if (claimFailures.length > 0) {
-          if (newlyClaimedToolCallIds.length > 0) {
-            reqLogger.info('Releasing async tool claims after claim contention during resume', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              newlyClaimedToolCallIds,
-              claimFailures,
-            })
-            await Promise.all(
-              newlyClaimedToolCallIds.map((toolCallId) =>
-                releaseCompletedAsyncToolClaim(toolCallId, resumeWorkerId).catch(() => null)
-              )
-            )
-          }
-          if (resumeRetries < 3) {
-            resumeRetries++
-            reqLogger.info('Retrying async resume after claim contention', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              retry: resumeRetries,
-              claimFailures,
-            })
-            await new Promise((resolve) => setTimeout(resolve, 250 * resumeRetries))
-            continue
-          }
-          reqLogger.error('Async continuation failed because tool claims could not be acquired', {
-            checkpointId: continuation.checkpointId,
-            runId: continuation.runId,
-            claimFailures,
-          })
-          throw new Error(
-            `Failed to resume async tool continuation: unable to claim tool calls (${claimFailures.join(', ')})`
-          )
-        }
-
-        claimedToolCallIds = [
-          ...readyTools
-            .filter((tool) => tool.alreadyClaimedByWorker)
-            .map((tool) => tool.toolCallId),
-          ...newlyClaimedToolCallIds,
-        ]
-        claimedByWorkerId = claimedToolCallIds.length > 0 ? resumeWorkerId : null
-
-        reqLogger.info('Resuming async tool continuation', {
-          checkpointId: continuation.checkpointId,
-          runId: continuation.runId,
-          workerId: resumeWorkerId,
-          toolCallIds: readyTools.map((tool) => tool.toolCallId),
-        })
-
-        const durableRows = await getAsyncToolCalls(
-          readyTools.map((tool) => tool.toolCallId)
-        ).catch(() => [])
-        const durableByToolCallId = new Map(durableRows.map((row) => [row.toolCallId, row]))
-
-        const results = await Promise.all(
-          readyTools.map(async (tool) => {
-            const durable = durableByToolCallId.get(tool.toolCallId) || tool.durableRow
-            const durableStatus = durable?.status
-            const durableResult =
-              durable?.result && typeof durable.result === 'object'
-                ? (durable.result as Record<string, unknown>)
-                : undefined
-            const success = didAsyncToolSucceed({
-              durableStatus,
-              durableResult,
-              durableError: durable?.error,
-              toolStateStatus: tool.toolState?.status,
-            })
-            const data =
-              durableResult ||
-              (tool.toolState?.result?.output as Record<string, unknown> | undefined) ||
-              (success
-                ? { message: 'Tool completed' }
-                : {
-                    error: durable?.error || tool.toolState?.error || 'Tool failed',
-                  })
-
-            if (
-              durableStatus &&
-              !isTerminalAsyncStatus(durableStatus) &&
-              !isDeliveredAsyncStatus(durableStatus)
-            ) {
-              reqLogger.warn(
-                'Async tool row was claimed for resume without terminal durable state',
-                {
-                  toolCallId: tool.toolCallId,
-                  status: durableStatus,
-                }
-              )
-            }
-
-            return {
-              callId: tool.toolCallId,
-              name: durable?.toolName || tool.toolState?.name || '',
-              data,
-              success,
-            }
-          })
-        )
-
-        context.awaitingAsyncContinuation = undefined
-        route = '/api/tools/resume'
-        payload = {
-          checkpointId: continuation.checkpointId,
-          results,
-        }
-        reqLogger.info('Prepared async continuation payload for resume endpoint', {
-          route,
-          checkpointId: continuation.checkpointId,
-          resultCount: results.length,
-        })
-        resumeReady = true
-        break
-      }
-
-      if (!resumeReady) {
-        reqLogger.warn('Async continuation loop exited without resume payload', {
-          checkpointId: continuation.checkpointId,
-          runId: continuation.runId,
-        })
-        break
-      }
-    }
-
-    const result: OrchestratorResult = {
-      success: context.errors.length === 0 && !context.wasAborted,
-      content: context.accumulatedContent,
-      contentBlocks: context.contentBlocks,
-      toolCalls: buildToolCallSummaries(context),
-      chatId: context.chatId,
-      requestId: context.requestId,
-      errors: context.errors.length ? context.errors : undefined,
-      usage: context.usage,
-      cost: context.cost,
-    }
-    reqLogger.info('Completing copilot orchestration', {
-      success: result.success,
-      chatId: result.chatId,
-      hasRequestId: Boolean(result.requestId),
-      errorCount: result.errors?.length || 0,
-      toolCallCount: result.toolCalls.length,
-    })
-    await options.onComplete?.(result)
-    return result
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error('Copilot orchestration failed')
-    if (claimedToolCallIds.length > 0 && claimedByWorkerId) {
-      reqLogger.warn('Releasing async tool claims after delivery failure', {
-        toolCallIds: claimedToolCallIds,
-        workerId: claimedByWorkerId,
-      })
-      await Promise.all(
-        claimedToolCallIds.map((toolCallId) =>
-          releaseCompletedAsyncToolClaim(toolCallId, claimedByWorkerId!).catch(() => null)
-        )
-      )
-    }
-    reqLogger.error('Copilot orchestration failed', {
-      error: err.message,
-    })
-    await options.onError?.(err)
-    return {
-      success: false,
-      content: '',
-      contentBlocks: [],
-      toolCalls: [],
-      chatId: context.chatId,
-      error: err.message,
-    }
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.test.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.test.ts
deleted file mode 100644
index 84099340c83..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.test.ts
+++ /dev/null
@@ -1,293 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { loggerMock } from '@sim/testing'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('@sim/logger', () => loggerMock)
-
-const { executeToolServerSide, markToolComplete, isToolAvailableOnSimSide } = vi.hoisted(() => ({
-  executeToolServerSide: vi.fn(),
-  markToolComplete: vi.fn(),
-  isToolAvailableOnSimSide: vi.fn().mockReturnValue(true),
-}))
-
-const { upsertAsyncToolCall } = vi.hoisted(() => ({
-  upsertAsyncToolCall: vi.fn(),
-}))
-
-vi.mock('@/lib/copilot/orchestrator/tool-executor', () => ({
-  executeToolServerSide,
-  markToolComplete,
-  isToolAvailableOnSimSide,
-}))
-
-vi.mock('@/lib/copilot/async-runs/repository', async () => {
-  const actual = await vi.importActual<typeof import('@/lib/copilot/async-runs/repository')>(
-    '@/lib/copilot/async-runs/repository'
-  )
-  return {
-    ...actual,
-    upsertAsyncToolCall,
-  }
-})
-
-import { sseHandlers } from '@/lib/copilot/orchestrator/sse/handlers'
-import type { ExecutionContext, StreamingContext } from '@/lib/copilot/orchestrator/types'
-
-describe('sse-handlers tool lifecycle', () => {
-  let context: StreamingContext
-  let execContext: ExecutionContext
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    upsertAsyncToolCall.mockResolvedValue(null)
-    context = {
-      chatId: undefined,
-      messageId: 'msg-1',
-      accumulatedContent: '',
-      contentBlocks: [],
-      toolCalls: new Map(),
-      pendingToolPromises: new Map(),
-      currentThinkingBlock: null,
-      isInThinkingBlock: false,
-      subAgentParentToolCallId: undefined,
-      subAgentParentStack: [],
-      subAgentContent: {},
-      subAgentToolCalls: {},
-      pendingContent: '',
-      streamComplete: false,
-      wasAborted: false,
-      errors: [],
-    }
-    execContext = {
-      userId: 'user-1',
-      workflowId: 'workflow-1',
-    }
-  })
-
-  it('executes tool_call and emits tool_result + mark-complete', async () => {
-    executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
-    markToolComplete.mockResolvedValueOnce(true)
-    const onEvent = vi.fn()
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-1', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    // tool_call fires execution without awaiting (fire-and-forget for parallel execution),
-    // so we flush pending microtasks before asserting
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-    expect(onEvent).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'tool_result',
-        toolCallId: 'tool-1',
-        success: true,
-      })
-    )
-
-    const updated = context.toolCalls.get('tool-1')
-    expect(updated?.status).toBe('success')
-    expect(updated?.result?.output).toEqual({ ok: true })
-  })
-
-  it('skips duplicate tool_call after result', async () => {
-    executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
-    markToolComplete.mockResolvedValueOnce(true)
-
-    const event = {
-      type: 'tool_call',
-      data: { id: 'tool-dup', name: 'read', arguments: { workflowId: 'workflow-1' } },
-    }
-
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-    await new Promise((resolve) => setTimeout(resolve, 0))
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-  })
-
-  it('marks an in-flight tool as cancelled when aborted mid-execution', async () => {
-    const abortController = new AbortController()
-    const userStopController = new AbortController()
-    execContext.abortSignal = abortController.signal
-    execContext.userStopSignal = userStopController.signal
-
-    executeToolServerSide.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          setTimeout(() => resolve({ success: true, output: { ok: true } }), 0)
-        })
-    )
-    markToolComplete.mockResolvedValue(true)
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-cancel', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      {
-        interactive: false,
-        timeout: 1000,
-        abortSignal: abortController.signal,
-        userStopSignal: userStopController.signal,
-      }
-    )
-
-    userStopController.abort()
-    abortController.abort()
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    expect(markToolComplete).toHaveBeenCalledWith(
-      'tool-cancel',
-      'read',
-      499,
-      'Request aborted during tool execution',
-      { cancelled: true },
-      'msg-1'
-    )
-
-    const updated = context.toolCalls.get('tool-cancel')
-    expect(updated?.status).toBe('cancelled')
-  })
-
-  it('does not replace an in-flight pending promise on duplicate tool_call', async () => {
-    let resolveTool: ((value: { success: boolean; output: { ok: boolean } }) => void) | undefined
-    executeToolServerSide.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          resolveTool = resolve
-        })
-    )
-    markToolComplete.mockResolvedValueOnce(true)
-
-    const event = {
-      type: 'tool_call',
-      data: { id: 'tool-inflight', name: 'read', arguments: { workflowId: 'workflow-1' } },
-    }
-
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    const firstPromise = context.pendingToolPromises.get('tool-inflight')
-    expect(firstPromise).toBeDefined()
-
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(context.pendingToolPromises.get('tool-inflight')).toBe(firstPromise)
-
-    resolveTool?.({ success: true, output: { ok: true } })
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(context.pendingToolPromises.has('tool-inflight')).toBe(false)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-  })
-
-  it('still executes the tool when async row upsert fails', async () => {
-    upsertAsyncToolCall.mockRejectedValueOnce(new Error('db down'))
-    executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
-    markToolComplete.mockResolvedValueOnce(true)
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-upsert-fail', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
-    )
-
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-    expect(context.toolCalls.get('tool-upsert-fail')?.status).toBe('success')
-  })
-
-  it('does not execute a tool if a terminal tool_result arrives before local execution starts', async () => {
-    let resolveUpsert: ((value: null) => void) | undefined
-    upsertAsyncToolCall.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          resolveUpsert = resolve
-        })
-    )
-    const onEvent = vi.fn()
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-race', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    await sseHandlers.tool_result(
-      {
-        type: 'tool_result',
-        toolCallId: 'tool-race',
-        data: { id: 'tool-race', success: true, result: { ok: true } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    resolveUpsert?.(null)
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).not.toHaveBeenCalled()
-    expect(markToolComplete).not.toHaveBeenCalled()
-    expect(context.toolCalls.get('tool-race')?.status).toBe('success')
-    expect(context.toolCalls.get('tool-race')?.result?.output).toEqual({ ok: true })
-  })
-
-  it('does not execute a tool if a tool_result arrives before the tool_call event', async () => {
-    const onEvent = vi.fn()
-
-    await sseHandlers.tool_result(
-      {
-        type: 'tool_result',
-        toolCallId: 'tool-early-result',
-        toolName: 'read',
-        data: { id: 'tool-early-result', name: 'read', success: true, result: { ok: true } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-early-result', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).not.toHaveBeenCalled()
-    expect(markToolComplete).not.toHaveBeenCalled()
-    expect(context.toolCalls.get('tool-early-result')?.status).toBe('success')
-  })
-})
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.ts
deleted file mode 100644
index 7fb50f4c9b9..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.ts
+++ /dev/null
@@ -1,853 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
-import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
-import {
-  asRecord,
-  getEventData,
-  markToolResultSeen,
-  wasToolResultSeen,
-} from '@/lib/copilot/orchestrator/sse/utils'
-import {
-  isToolAvailableOnSimSide,
-  markToolComplete,
-} from '@/lib/copilot/orchestrator/tool-executor'
-import type {
-  ContentBlock,
-  ExecutionContext,
-  OrchestratorOptions,
-  SSEEvent,
-  StreamingContext,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { isWorkflowToolName } from '@/lib/copilot/workflow-tools'
-import { generateId } from '@/lib/core/utils/uuid'
-import { executeToolAndReport, waitForToolCompletion } from './tool-execution'
-
-const logger = createLogger('CopilotSseHandlers')
-
-/**
- * Builds an AbortSignal that fires when either the main abort signal OR
- * the client-disconnect signal fires. Used for client-executable tool waits
- * so the orchestrator doesn't block for the full timeout when the browser dies.
- */
-function buildClientToolAbortSignal(options: OrchestratorOptions): AbortSignal | undefined {
-  const { abortSignal, clientDisconnectedSignal } = options
-  if (!clientDisconnectedSignal || clientDisconnectedSignal.aborted) {
-    return clientDisconnectedSignal?.aborted ? AbortSignal.abort() : abortSignal
-  }
-  if (!abortSignal) return clientDisconnectedSignal
-
-  const combined = new AbortController()
-  const fire = () => combined.abort()
-  abortSignal.addEventListener('abort', fire, { once: true })
-  clientDisconnectedSignal.addEventListener('abort', fire, { once: true })
-  return combined.signal
-}
-
-function registerPendingToolPromise(
-  context: StreamingContext,
-  toolCallId: string,
-  pendingPromise: Promise<{ status: string; message?: string; data?: Record<string, unknown> }>
-) {
-  context.pendingToolPromises.set(toolCallId, pendingPromise)
-  pendingPromise.finally(() => {
-    if (context.pendingToolPromises.get(toolCallId) === pendingPromise) {
-      context.pendingToolPromises.delete(toolCallId)
-    }
-  })
-}
-
-/**
- * When the Sim→Go stream is aborted, avoid starting server-side tool work and
- * unblock the Go async waiter with a terminal 499 completion.
- */
-function abortPendingToolIfStreamDead(
-  toolCall: ToolCallState,
-  toolCallId: string,
-  options: OrchestratorOptions,
-  context: StreamingContext
-): boolean {
-  if (!options.abortSignal?.aborted && !context.wasAborted) {
-    return false
-  }
-  toolCall.status = 'cancelled'
-  toolCall.endTime = Date.now()
-  markToolResultSeen(toolCallId)
-  markToolComplete(
-    toolCall.id,
-    toolCall.name,
-    499,
-    'Request aborted before tool execution',
-    {
-      cancelled: true,
-    },
-    context.messageId
-  ).catch((err) => {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('markToolComplete fire-and-forget failed (stream aborted)', {
-        toolCallId: toolCall.id,
-        error: err instanceof Error ? err.message : String(err),
-      })
-  })
-  return true
-}
-
-/**
- * Extract the `ui` object from an SSE event. The server enriches
- * tool_call events with `ui: { requiresConfirmation, clientExecutable, ... }`.
- */
-function getEventUI(event: SSEEvent): {
-  requiresConfirmation: boolean
-  clientExecutable: boolean
-  internal: boolean
-  hidden: boolean
-} {
-  const raw = asRecord((event as unknown as Record<string, unknown>).ui)
-  return {
-    requiresConfirmation: raw.requiresConfirmation === true,
-    clientExecutable: raw.clientExecutable === true,
-    internal: raw.internal === true,
-    hidden: raw.hidden === true,
-  }
-}
-
-/**
- * Handle the completion signal from a client-executable tool.
- * Shared by both the main and subagent tool_call handlers.
- */
-function handleClientCompletion(
-  toolCall: ToolCallState,
-  toolCallId: string,
-  completion: { status: string; message?: string; data?: Record<string, unknown> } | null,
-  context: StreamingContext
-): void {
-  if (completion?.status === 'background') {
-    toolCall.status = 'skipped'
-    toolCall.endTime = Date.now()
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      202,
-      completion.message || 'Tool execution moved to background',
-      { background: true },
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed (client background)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-    markToolResultSeen(toolCallId)
-    return
-  }
-  if (completion?.status === 'rejected') {
-    toolCall.status = 'rejected'
-    toolCall.endTime = Date.now()
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      400,
-      completion.message || 'Tool execution rejected',
-      undefined,
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed (client rejected)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-    markToolResultSeen(toolCallId)
-    return
-  }
-  if (completion?.status === 'cancelled') {
-    toolCall.status = 'cancelled'
-    toolCall.endTime = Date.now()
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      499,
-      completion.message || 'Workflow execution was stopped manually by the user.',
-      completion.data,
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed (client cancelled)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-    markToolResultSeen(toolCallId)
-    return
-  }
-  const success = completion?.status === 'success'
-  toolCall.status = success ? 'success' : 'error'
-  toolCall.endTime = Date.now()
-  const msg = completion?.message || (success ? 'Tool completed' : 'Tool failed or timed out')
-  markToolComplete(
-    toolCall.id,
-    toolCall.name,
-    success ? 200 : 500,
-    msg,
-    completion?.data,
-    context.messageId
-  ).catch((err) => {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('markToolComplete fire-and-forget failed (client completion)', {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        error: err instanceof Error ? err.message : String(err),
-      })
-  })
-  markToolResultSeen(toolCallId)
-}
-
-/**
- * Emit a synthetic tool_result SSE event to the client after a client-executable
- * tool completes. The server's actual tool_result is skipped (markToolResultSeen),
- * so the client would never learn the outcome without this.
- */
-async function emitSyntheticToolResult(
-  toolCallId: string,
-  toolName: string,
-  completion: { status: string; message?: string; data?: Record<string, unknown> } | null,
-  options: OrchestratorOptions,
-  context: StreamingContext
-): Promise<void> {
-  const success = completion?.status === 'success'
-  const isCancelled = completion?.status === 'cancelled'
-
-  const resultPayload = isCancelled
-    ? { ...completion?.data, reason: 'user_cancelled', cancelledByUser: true }
-    : completion?.data
-
-  try {
-    await options.onEvent?.({
-      type: 'tool_result',
-      toolCallId,
-      toolName,
-      success,
-      result: resultPayload,
-      error: !success ? completion?.message : undefined,
-    } as SSEEvent)
-  } catch (error) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to emit synthetic tool_result', {
-        toolCallId,
-        toolName,
-        error: error instanceof Error ? error.message : String(error),
-      })
-  }
-}
-
-// Normalization + dedupe helpers live in sse-utils to keep server/client in sync.
-
-function inferToolSuccess(data: Record<string, unknown> | undefined): {
-  success: boolean
-  hasResultData: boolean
-  hasError: boolean
-} {
-  const resultObj = asRecord(data?.result)
-  const hasExplicitSuccess = data?.success !== undefined || resultObj.success !== undefined
-  const explicitSuccess = data?.success ?? resultObj.success
-  const hasResultData = data?.result !== undefined || data?.data !== undefined
-  const hasError = !!data?.error || !!resultObj.error
-  const success = hasExplicitSuccess ? !!explicitSuccess : !hasError
-  return { success, hasResultData, hasError }
-}
-
-function ensureTerminalToolCallState(
-  context: StreamingContext,
-  toolCallId: string,
-  toolName: string
-): ToolCallState {
-  const existing = context.toolCalls.get(toolCallId)
-  if (existing) {
-    return existing
-  }
-
-  const toolCall: ToolCallState = {
-    id: toolCallId,
-    name: toolName || 'unknown_tool',
-    status: 'pending',
-    startTime: Date.now(),
-  }
-  context.toolCalls.set(toolCallId, toolCall)
-  addContentBlock(context, { type: 'tool_call', toolCall })
-  return toolCall
-}
-
-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(),
-  })
-}
-
-export const sseHandlers: Record<string, SSEHandler> = {
-  chat_id: (event, context, execContext) => {
-    const chatId = asRecord(event.data).chatId as string | undefined
-    context.chatId = chatId
-    if (chatId) {
-      execContext.chatId = chatId
-    }
-  },
-  request_id: (event, context) => {
-    const rid = typeof event.data === 'string' ? event.data : undefined
-    if (rid) {
-      context.requestId = rid
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .info('Mapped copilot message to Go trace ID', {
-          goTraceId: rid,
-          chatId: context.chatId,
-          executionId: context.executionId,
-          runId: context.runId,
-        })
-    }
-  },
-  title_updated: () => {},
-  tool_result: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const toolName =
-      event.toolName ||
-      (data?.name as string | undefined) ||
-      context.toolCalls.get(toolCallId)?.name ||
-      ''
-    const current = ensureTerminalToolCallState(context, toolCallId, toolName)
-
-    const { success, hasResultData, hasError } = inferToolSuccess(data)
-
-    current.status = success ? 'success' : 'error'
-    current.endTime = Date.now()
-    if (hasResultData) {
-      current.result = {
-        success,
-        output: data?.result || data?.data,
-      }
-    }
-    if (hasError) {
-      const resultObj = asRecord(data?.result)
-      current.error = (data?.error || resultObj.error) as string | undefined
-    }
-    markToolResultSeen(toolCallId)
-  },
-  tool_error: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const toolName =
-      event.toolName ||
-      (data?.name as string | undefined) ||
-      context.toolCalls.get(toolCallId)?.name ||
-      ''
-    const current = ensureTerminalToolCallState(context, toolCallId, toolName)
-    current.status = 'error'
-    current.error = (data?.error as string | undefined) || 'Tool execution failed'
-    current.endTime = Date.now()
-    markToolResultSeen(toolCallId)
-  },
-  tool_call_delta: () => {
-    // Argument streaming delta — no action needed on orchestrator side
-  },
-  tool_generating: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId =
-      event.toolCallId ||
-      (data?.toolCallId as string | undefined) ||
-      (data?.id as string | undefined)
-    const toolName =
-      event.toolName || (data?.toolName as string | undefined) || (data?.name as string | undefined)
-    if (!toolCallId || !toolName) return
-    if (!context.toolCalls.has(toolCallId)) {
-      const toolCall = {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending' as const,
-        startTime: Date.now(),
-      }
-      context.toolCalls.set(toolCallId, toolCall)
-      addContentBlock(context, { type: 'tool_call', toolCall })
-    }
-  },
-  tool_call: async (event, context, execContext, options) => {
-    const toolData = getEventData(event) || ({} as Record<string, unknown>)
-    const toolCallId = (toolData.id as string | undefined) || event.toolCallId
-    const toolName = (toolData.name as string | undefined) || event.toolName
-    if (!toolCallId || !toolName) return
-
-    const args = (toolData.arguments || toolData.input || asRecord(event.data).input) as
-      | Record<string, unknown>
-      | undefined
-    const isPartial = toolData.partial === true
-    const existing = context.toolCalls.get(toolCallId)
-
-    if (
-      existing?.endTime ||
-      (existing && existing.status !== 'pending' && existing.status !== 'executing')
-    ) {
-      if (!existing.name && toolName) {
-        existing.name = toolName
-      }
-      if (!existing.params && args) {
-        existing.params = args
-      }
-      return
-    }
-
-    if (existing) {
-      if (args && !existing.params) existing.params = args
-      if (
-        !context.contentBlocks.some((b) => b.type === 'tool_call' && b.toolCall?.id === toolCallId)
-      ) {
-        addContentBlock(context, { type: 'tool_call', toolCall: existing })
-      }
-    } else {
-      const created = {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending' as const,
-        params: args,
-        startTime: Date.now(),
-      }
-      context.toolCalls.set(toolCallId, created)
-      addContentBlock(context, { type: 'tool_call', toolCall: created })
-    }
-
-    if (isPartial) return
-    if (wasToolResultSeen(toolCallId)) return
-    if (context.pendingToolPromises.has(toolCallId) || existing?.status === 'executing') {
-      return
-    }
-
-    const toolCall = context.toolCalls.get(toolCallId)
-    if (!toolCall) return
-
-    const { clientExecutable, internal } = getEventUI(event)
-
-    if (internal) {
-      return
-    }
-
-    if (!isToolAvailableOnSimSide(toolName) && !clientExecutable) {
-      return
-    }
-
-    /**
-     * Fire tool execution without awaiting so parallel tool calls from the
-     * same LLM turn execute concurrently. executeToolAndReport is self-contained:
-     * it updates tool state, calls markToolComplete, and emits result events.
-     */
-    const fireToolExecution = () => {
-      const pendingPromise = (async () => {
-        try {
-          await upsertAsyncToolCall({
-            runId: context.runId || generateId(),
-            toolCallId,
-            toolName,
-            args,
-          })
-        } catch (err) {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async tool row before execution', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        }
-        return executeToolAndReport(toolCallId, context, execContext, options)
-      })().catch((err) => {
-        logger
-          .withMetadata({ messageId: context.messageId })
-          .error('Parallel tool execution failed', {
-            toolCallId,
-            toolName,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        return {
-          status: 'error',
-          message: err instanceof Error ? err.message : String(err),
-          data: { error: err instanceof Error ? err.message : String(err) },
-        }
-      })
-      registerPendingToolPromise(context, toolCallId, pendingPromise)
-    }
-
-    if (options.interactive === false) {
-      if (options.autoExecuteTools !== false) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      }
-      return
-    }
-
-    // Client-executable tool: execute server-side if available, otherwise
-    // delegate to the client (React UI) and wait for completion.
-    // Workflow run tools are implemented on Sim for MCP/server callers but must
-    // still run in the browser when clientExecutable so the workflow terminal
-    // receives SSE block logs (executeWorkflowWithFullLogging).
-    if (clientExecutable) {
-      const delegateWorkflowRunToClient = isWorkflowToolName(toolName)
-      if (isToolAvailableOnSimSide(toolName) && !delegateWorkflowRunToClient) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      } else {
-        toolCall.status = 'executing'
-        await upsertAsyncToolCall({
-          runId: context.runId || generateId(),
-          toolCallId,
-          toolName,
-          args,
-          status: 'running',
-        }).catch((err) => {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async tool row for client-executable tool', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        })
-        const clientWaitSignal = buildClientToolAbortSignal(options)
-        const completion = await waitForToolCompletion(
-          toolCallId,
-          options.timeout || STREAM_TIMEOUT_MS,
-          clientWaitSignal
-        )
-        handleClientCompletion(toolCall, toolCallId, completion, context)
-        await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options, context)
-      }
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-        fireToolExecution()
-      }
-    }
-  },
-  reasoning: (event, context) => {
-    const d = asRecord(event.data)
-    const phase = d.phase || asRecord(d.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 = (d.data || d.content || event.content) as string | undefined
-    if (!chunk || !context.currentThinkingBlock) return
-    context.currentThinkingBlock.content = `${context.currentThinkingBlock.content || ''}${chunk}`
-  },
-  content: (event, context) => {
-    // Server sends content as a plain string in event.data, not wrapped in an object.
-    let chunk: string | undefined
-    if (typeof event.data === 'string') {
-      chunk = event.data
-    } else {
-      const d = asRecord(event.data)
-      chunk = (d.content || d.data || event.content) as string | undefined
-    }
-    if (!chunk) return
-    context.accumulatedContent += chunk
-    addContentBlock(context, { type: 'text', content: chunk })
-  },
-  done: (event, context) => {
-    const d = asRecord(event.data)
-    const response = asRecord(d.response)
-    const asyncPause = asRecord(response.async_pause)
-    if (asyncPause.checkpointId) {
-      context.awaitingAsyncContinuation = {
-        checkpointId: String(asyncPause.checkpointId),
-        executionId:
-          typeof asyncPause.executionId === 'string' ? asyncPause.executionId : context.executionId,
-        runId: typeof asyncPause.runId === 'string' ? asyncPause.runId : context.runId,
-        pendingToolCallIds: Array.isArray(asyncPause.pendingToolCallIds)
-          ? asyncPause.pendingToolCallIds.map((id) => String(id))
-          : [],
-      }
-    }
-    if (d.usage) {
-      const u = asRecord(d.usage)
-      context.usage = {
-        prompt: (u.input_tokens as number) || 0,
-        completion: (u.output_tokens as number) || 0,
-      }
-    }
-    if (d.cost) {
-      const c = asRecord(d.cost)
-      context.cost = {
-        input: (c.input as number) || 0,
-        output: (c.output as number) || 0,
-        total: (c.total as number) || 0,
-      }
-    }
-    context.streamComplete = true
-  },
-  start: () => {},
-  error: (event, context) => {
-    const d = asRecord(event.data)
-    const message = (d.message || d.error || event.error) as string | undefined
-    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
-    // Server sends content as a plain string in event.data
-    let chunk: string | undefined
-    if (typeof event.data === 'string') {
-      chunk = event.data
-    } else {
-      const d = asRecord(event.data)
-      chunk = (d.content || d.data || event.content) as string | undefined
-    }
-    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) || ({} as Record<string, unknown>)
-    const toolCallId = (toolData.id as string | undefined) || event.toolCallId
-    const toolName = (toolData.name as string | undefined) || event.toolName
-    if (!toolCallId || !toolName) return
-    const isPartial = toolData.partial === true
-    const args = (toolData.arguments || toolData.input || asRecord(event.data).input) as
-      | Record<string, unknown>
-      | undefined
-
-    const existing = context.toolCalls.get(toolCallId)
-    // Ignore late/duplicate tool_call events once we already have a result.
-    if (wasToolResultSeen(toolCallId) || existing?.endTime) {
-      if (existing && !existing.name && toolName) {
-        existing.name = toolName
-      }
-      if (existing && !existing.params && args) {
-        existing.params = args
-      }
-      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)
-      const parentToolCall = context.toolCalls.get(parentToolCallId)
-      addContentBlock(context, {
-        type: 'tool_call',
-        toolCall,
-        calledBy: parentToolCall?.name,
-      })
-    }
-
-    if (isPartial) return
-    if (context.pendingToolPromises.has(toolCallId) || existing?.status === 'executing') {
-      return
-    }
-
-    const { clientExecutable, internal } = getEventUI(event)
-
-    if (internal) {
-      return
-    }
-
-    if (!isToolAvailableOnSimSide(toolName) && !clientExecutable) {
-      return
-    }
-
-    const fireToolExecution = () => {
-      const pendingPromise = (async () => {
-        try {
-          await upsertAsyncToolCall({
-            runId: context.runId || generateId(),
-            toolCallId,
-            toolName,
-            args,
-          })
-        } catch (err) {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async subagent tool row before execution', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        }
-        return executeToolAndReport(toolCallId, context, execContext, options)
-      })().catch((err) => {
-        logger
-          .withMetadata({ messageId: context.messageId })
-          .error('Parallel subagent tool execution failed', {
-            toolCallId,
-            toolName,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        return {
-          status: 'error',
-          message: err instanceof Error ? err.message : String(err),
-          data: { error: err instanceof Error ? err.message : String(err) },
-        }
-      })
-      registerPendingToolPromise(context, toolCallId, pendingPromise)
-    }
-
-    if (options.interactive === false) {
-      if (options.autoExecuteTools !== false) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      }
-      return
-    }
-
-    if (clientExecutable) {
-      const delegateWorkflowRunToClient = isWorkflowToolName(toolName)
-      if (isToolAvailableOnSimSide(toolName) && !delegateWorkflowRunToClient) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      } else {
-        toolCall.status = 'executing'
-        await upsertAsyncToolCall({
-          runId: context.runId || generateId(),
-          toolCallId,
-          toolName,
-          args,
-          status: 'running',
-        }).catch((err) => {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async tool row for client-executable subagent tool', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        })
-        const clientWaitSignal = buildClientToolAbortSignal(options)
-        const completion = await waitForToolCompletion(
-          toolCallId,
-          options.timeout || STREAM_TIMEOUT_MS,
-          clientWaitSignal
-        )
-        handleClientCompletion(toolCall, toolCallId, completion, context)
-        await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options, context)
-      }
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-        fireToolExecution()
-      }
-    }
-  },
-  tool_result: (event, context) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId) return
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const toolName = event.toolName || (data?.name as string | undefined) || ''
-
-    // 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 = ensureTerminalToolCallState(context, toolCallId, toolName)
-
-    const { success, hasResultData, hasError } = inferToolSuccess(data)
-
-    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) {
-        const resultObj = asRecord(data?.result)
-        subAgentToolCall.error = (data?.error || resultObj.error) as string | undefined
-      }
-    }
-
-    if (mainToolCall) {
-      mainToolCall.status = status
-      mainToolCall.endTime = endTime
-      if (result) mainToolCall.result = result
-      if (hasError) {
-        const resultObj = asRecord(data?.result)
-        mainToolCall.error = (data?.error || resultObj.error) as string | undefined
-      }
-    }
-    if (subAgentToolCall || mainToolCall) {
-      markToolResultSeen(toolCallId)
-    }
-  },
-}
-
-export function handleSubagentRouting(event: SSEEvent, context: StreamingContext): boolean {
-  if (!event.subagent) return false
-  if (!context.subAgentParentToolCallId) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Subagent event missing parent tool call', {
-        type: event.type,
-        subagent: event.subagent,
-      })
-    return false
-  }
-  return true
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/index.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/index.ts
deleted file mode 100644
index d0d6b14b5bf..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export type { SSEHandler } from './handlers'
-export { handleSubagentRouting, sseHandlers, subAgentHandlers } from './handlers'
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/tool-execution.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/tool-execution.ts
deleted file mode 100644
index e960b08a1fe..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/tool-execution.ts
+++ /dev/null
@@ -1,937 +0,0 @@
-import { db } from '@sim/db'
-import { userTableRows } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { completeAsyncToolCall, markAsyncToolRunning } from '@/lib/copilot/async-runs/repository'
-import { waitForToolConfirmation } from '@/lib/copilot/orchestrator/persistence'
-import { asRecord, markToolResultSeen } from '@/lib/copilot/orchestrator/sse/utils'
-import { executeToolServerSide, markToolComplete } from '@/lib/copilot/orchestrator/tool-executor'
-import {
-  type ExecutionContext,
-  isTerminalToolCallStatus,
-  type OrchestratorOptions,
-  type SSEEvent,
-  type StreamingContext,
-  type ToolCallResult,
-} from '@/lib/copilot/orchestrator/types'
-import {
-  extractDeletedResourcesFromToolResult,
-  extractResourcesFromToolResult,
-  hasDeleteCapability,
-  isResourceToolName,
-  persistChatResources,
-  removeChatResources,
-} from '@/lib/copilot/resources'
-import { generateId } from '@/lib/core/utils/uuid'
-import { getTableById } from '@/lib/table/service'
-import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-
-const logger = createLogger('CopilotSseToolExecution')
-
-const OUTPUT_PATH_TOOLS = new Set(['function_execute', 'user_table'])
-
-/**
- * Try to pull a flat array of row-objects out of the various shapes that
- * `function_execute` and `user_table` can return.
- */
-function extractTabularData(output: unknown): Record<string, unknown>[] | null {
-  if (!output || typeof output !== 'object') return null
-
-  if (Array.isArray(output)) {
-    if (output.length > 0 && typeof output[0] === 'object' && output[0] !== null) {
-      return output as Record<string, unknown>[]
-    }
-    return null
-  }
-
-  const obj = output as Record<string, unknown>
-
-  // function_execute shape: { result: [...], stdout: "..." }
-  if (Array.isArray(obj.result)) {
-    const rows = obj.result
-    if (rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null) {
-      return rows as Record<string, unknown>[]
-    }
-  }
-
-  // user_table query_rows shape: { data: { rows: [{ data: {...} }], totalCount } }
-  if (obj.data && typeof obj.data === 'object' && !Array.isArray(obj.data)) {
-    const data = obj.data as Record<string, unknown>
-    if (Array.isArray(data.rows) && data.rows.length > 0) {
-      const rows = data.rows as Record<string, unknown>[]
-      // user_table rows nest actual values inside .data
-      if (typeof rows[0].data === 'object' && rows[0].data !== null) {
-        return rows.map((r) => r.data as Record<string, unknown>)
-      }
-      return rows
-    }
-  }
-
-  return null
-}
-
-function escapeCsvValue(value: unknown): string {
-  if (value === null || value === undefined) return ''
-  const str = typeof value === 'object' ? JSON.stringify(value) : String(value)
-  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
-    return `"${str.replace(/"/g, '""')}"`
-  }
-  return str
-}
-
-function convertRowsToCsv(rows: Record<string, unknown>[]): string {
-  if (rows.length === 0) return ''
-
-  const headerSet = new Set<string>()
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      headerSet.add(key)
-    }
-  }
-  const headers = [...headerSet]
-
-  const lines = [headers.map(escapeCsvValue).join(',')]
-  for (const row of rows) {
-    lines.push(headers.map((h) => escapeCsvValue(row[h])).join(','))
-  }
-  return lines.join('\n')
-}
-
-type OutputFormat = 'json' | 'csv' | 'txt' | 'md' | 'html'
-
-const EXT_TO_FORMAT: Record<string, OutputFormat> = {
-  '.json': 'json',
-  '.csv': 'csv',
-  '.txt': 'txt',
-  '.md': 'md',
-  '.html': 'html',
-}
-
-const FORMAT_TO_CONTENT_TYPE: Record<OutputFormat, string> = {
-  json: 'application/json',
-  csv: 'text/csv',
-  txt: 'text/plain',
-  md: 'text/markdown',
-  html: 'text/html',
-}
-
-function normalizeOutputWorkspaceFileName(outputPath: string): string {
-  const trimmed = outputPath.trim().replace(/^\/+/, '')
-  const withoutPrefix = trimmed.startsWith('files/') ? trimmed.slice('files/'.length) : trimmed
-  if (!withoutPrefix) {
-    throw new Error('outputPath must include a file name, e.g. "files/result.json"')
-  }
-  if (withoutPrefix.includes('/')) {
-    throw new Error(
-      'outputPath must target a flat workspace file, e.g. "files/result.json". Nested paths like "files/reports/result.json" are not supported.'
-    )
-  }
-  return withoutPrefix
-}
-
-function resolveOutputFormat(fileName: string, explicit?: string): OutputFormat {
-  if (explicit && explicit in FORMAT_TO_CONTENT_TYPE) return explicit as OutputFormat
-  const ext = fileName.slice(fileName.lastIndexOf('.')).toLowerCase()
-  return EXT_TO_FORMAT[ext] ?? 'json'
-}
-
-function serializeOutputForFile(output: unknown, format: OutputFormat): string {
-  if (typeof output === 'string') return output
-
-  if (format === 'csv') {
-    const rows = extractTabularData(output)
-    if (rows && rows.length > 0) {
-      return convertRowsToCsv(rows)
-    }
-  }
-
-  return JSON.stringify(output, null, 2)
-}
-
-async function maybeWriteOutputToFile(
-  toolName: string,
-  params: Record<string, unknown> | undefined,
-  result: ToolCallResult,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  if (!result.success || !result.output) return result
-  if (!OUTPUT_PATH_TOOLS.has(toolName)) return result
-  if (!context.workspaceId || !context.userId) return result
-
-  const args = params?.args as Record<string, unknown> | undefined
-  const outputPath =
-    (params?.outputPath as string | undefined) ?? (args?.outputPath as string | undefined)
-  if (!outputPath) return result
-
-  const explicitFormat =
-    (params?.outputFormat as string | undefined) ?? (args?.outputFormat as string | undefined)
-
-  try {
-    const fileName = normalizeOutputWorkspaceFileName(outputPath)
-    const format = resolveOutputFormat(fileName, explicitFormat)
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    const content = serializeOutputForFile(result.output, format)
-    const contentType = FORMAT_TO_CONTENT_TYPE[format]
-
-    const buffer = Buffer.from(content, 'utf-8')
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    const uploaded = await uploadWorkspaceFile(
-      context.workspaceId,
-      context.userId,
-      buffer,
-      fileName,
-      contentType
-    )
-
-    logger.withMetadata({ messageId: context.messageId }).info('Tool output written to file', {
-      toolName,
-      fileName,
-      size: buffer.length,
-      fileId: uploaded.id,
-    })
-
-    return {
-      success: true,
-      output: {
-        message: `Output written to files/${fileName} (${buffer.length} bytes)`,
-        fileId: uploaded.id,
-        fileName,
-        size: buffer.length,
-        downloadUrl: uploaded.url,
-      },
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err)
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to write tool output to file', {
-        toolName,
-        outputPath,
-        error: message,
-      })
-    return {
-      success: false,
-      error: `Failed to write output file: ${message}`,
-    }
-  }
-}
-
-const MAX_OUTPUT_TABLE_ROWS = 10_000
-const BATCH_CHUNK_SIZE = 500
-
-export interface AsyncToolCompletion {
-  status: string
-  message?: string
-  data?: Record<string, unknown>
-}
-
-function abortRequested(
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options?: OrchestratorOptions
-): boolean {
-  if (options?.userStopSignal?.aborted || execContext.userStopSignal?.aborted) {
-    return true
-  }
-  if (context.wasAborted) {
-    return true
-  }
-  return false
-}
-
-function cancelledCompletion(message: string): AsyncToolCompletion {
-  return {
-    status: 'cancelled',
-    message,
-    data: { cancelled: true },
-  }
-}
-
-function terminalCompletionFromToolCall(toolCall: {
-  status: string
-  error?: string
-  result?: { output?: unknown; error?: string }
-}): AsyncToolCompletion {
-  if (toolCall.status === 'cancelled') {
-    return cancelledCompletion(toolCall.error || 'Tool execution cancelled')
-  }
-
-  if (toolCall.status === 'success') {
-    return {
-      status: 'success',
-      message: 'Tool completed',
-      data:
-        toolCall.result?.output &&
-        typeof toolCall.result.output === 'object' &&
-        !Array.isArray(toolCall.result.output)
-          ? (toolCall.result.output as Record<string, unknown>)
-          : undefined,
-    }
-  }
-
-  if (toolCall.status === 'skipped') {
-    return {
-      status: 'success',
-      message: 'Tool skipped',
-      data:
-        toolCall.result?.output &&
-        typeof toolCall.result.output === 'object' &&
-        !Array.isArray(toolCall.result.output)
-          ? (toolCall.result.output as Record<string, unknown>)
-          : undefined,
-    }
-  }
-
-  return {
-    status: toolCall.status === 'rejected' ? 'rejected' : 'error',
-    message: toolCall.error || toolCall.result?.error || 'Tool failed',
-    data: { error: toolCall.error || toolCall.result?.error || 'Tool failed' },
-  }
-}
-
-function reportCancelledTool(
-  toolCall: { id: string; name: string },
-  message: string,
-  messageId?: string,
-  data: Record<string, unknown> = { cancelled: true }
-): void {
-  markToolComplete(toolCall.id, toolCall.name, 499, message, data, messageId).catch((err) => {
-    logger.withMetadata({ messageId }).error('markToolComplete failed (cancelled)', {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      error: err instanceof Error ? err.message : String(err),
-    })
-  })
-}
-
-async function maybeWriteOutputToTable(
-  toolName: string,
-  params: Record<string, unknown> | undefined,
-  result: ToolCallResult,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  if (toolName !== 'function_execute') return result
-  if (!result.success || !result.output) return result
-  if (!context.workspaceId || !context.userId) return result
-
-  const outputTable = params?.outputTable as string | undefined
-  if (!outputTable) return result
-
-  try {
-    const table = await getTableById(outputTable)
-    if (!table) {
-      return {
-        success: false,
-        error: `Table "${outputTable}" not found`,
-      }
-    }
-
-    const rawOutput = result.output
-    let rows: Array<Record<string, unknown>>
-
-    if (rawOutput && typeof rawOutput === 'object' && 'result' in rawOutput) {
-      const inner = (rawOutput as Record<string, unknown>).result
-      if (Array.isArray(inner)) {
-        rows = inner
-      } else {
-        return {
-          success: false,
-          error: 'outputTable requires the code to return an array of objects',
-        }
-      }
-    } else if (Array.isArray(rawOutput)) {
-      rows = rawOutput
-    } else {
-      return {
-        success: false,
-        error: 'outputTable requires the code to return an array of objects',
-      }
-    }
-
-    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
-      return {
-        success: false,
-        error: `outputTable row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
-      }
-    }
-
-    if (rows.length === 0) {
-      return {
-        success: false,
-        error: 'outputTable requires at least one row — code returned an empty array',
-      }
-    }
-
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    await db.transaction(async (tx) => {
-      if (context.abortSignal?.aborted) {
-        throw new Error('Request aborted before tool mutation could be applied')
-      }
-      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
-
-      const now = new Date()
-      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
-        if (context.abortSignal?.aborted) {
-          throw new Error('Request aborted before tool mutation could be applied')
-        }
-        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
-        const values = chunk.map((rowData, j) => ({
-          id: `row_${generateId().replace(/-/g, '')}`,
-          tableId: outputTable,
-          workspaceId: context.workspaceId!,
-          data: rowData,
-          position: i + j,
-          createdAt: now,
-          updatedAt: now,
-          createdBy: context.userId,
-        }))
-        await tx.insert(userTableRows).values(values)
-      }
-    })
-
-    logger.withMetadata({ messageId: context.messageId }).info('Tool output written to table', {
-      toolName,
-      tableId: outputTable,
-      rowCount: rows.length,
-    })
-
-    return {
-      success: true,
-      output: {
-        message: `Wrote ${rows.length} rows to table ${outputTable}`,
-        tableId: outputTable,
-        rowCount: rows.length,
-      },
-    }
-  } catch (err) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to write tool output to table', {
-        toolName,
-        outputTable,
-        error: err instanceof Error ? err.message : String(err),
-      })
-    return {
-      success: false,
-      error: `Failed to write to table: ${err instanceof Error ? err.message : String(err)}`,
-    }
-  }
-}
-
-async function maybeWriteReadCsvToTable(
-  toolName: string,
-  params: Record<string, unknown> | undefined,
-  result: ToolCallResult,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  if (toolName !== 'read') return result
-  if (!result.success || !result.output) return result
-  if (!context.workspaceId || !context.userId) return result
-
-  const outputTable = params?.outputTable as string | undefined
-  if (!outputTable) return result
-
-  try {
-    const table = await getTableById(outputTable)
-    if (!table) {
-      return { success: false, error: `Table "${outputTable}" not found` }
-    }
-
-    const output = result.output as Record<string, unknown>
-    const content = (output.content as string) || ''
-    if (!content.trim()) {
-      return { success: false, error: 'File has no content to import into table' }
-    }
-
-    const filePath = (params?.path as string) || ''
-    const ext = filePath.split('.').pop()?.toLowerCase()
-
-    let rows: Record<string, unknown>[]
-
-    if (ext === 'json') {
-      const parsed = JSON.parse(content)
-      if (!Array.isArray(parsed)) {
-        return {
-          success: false,
-          error: 'JSON file must contain an array of objects for table import',
-        }
-      }
-      rows = parsed
-    } else {
-      const { parse } = await import('csv-parse/sync')
-      rows = parse(content, {
-        columns: true,
-        skip_empty_lines: true,
-        trim: true,
-        relax_column_count: true,
-        relax_quotes: true,
-        skip_records_with_error: true,
-        cast: false,
-      }) as Record<string, unknown>[]
-    }
-
-    if (rows.length === 0) {
-      return { success: false, error: 'File has no data rows to import' }
-    }
-
-    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
-      return {
-        success: false,
-        error: `Row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
-      }
-    }
-
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    await db.transaction(async (tx) => {
-      if (context.abortSignal?.aborted) {
-        throw new Error('Request aborted before tool mutation could be applied')
-      }
-      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
-
-      const now = new Date()
-      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
-        if (context.abortSignal?.aborted) {
-          throw new Error('Request aborted before tool mutation could be applied')
-        }
-        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
-        const values = chunk.map((rowData, j) => ({
-          id: `row_${generateId().replace(/-/g, '')}`,
-          tableId: outputTable,
-          workspaceId: context.workspaceId!,
-          data: rowData,
-          position: i + j,
-          createdAt: now,
-          updatedAt: now,
-          createdBy: context.userId,
-        }))
-        await tx.insert(userTableRows).values(values)
-      }
-    })
-
-    logger.withMetadata({ messageId: context.messageId }).info('Read output written to table', {
-      toolName,
-      tableId: outputTable,
-      tableName: table.name,
-      rowCount: rows.length,
-      filePath,
-    })
-
-    return {
-      success: true,
-      output: {
-        message: `Imported ${rows.length} rows from "${filePath}" into table "${table.name}"`,
-        tableId: outputTable,
-        tableName: table.name,
-        rowCount: rows.length,
-      },
-    }
-  } catch (err) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to write read output to table', {
-        toolName,
-        outputTable,
-        error: err instanceof Error ? err.message : String(err),
-      })
-    return {
-      success: false,
-      error: `Failed to import into table: ${err instanceof Error ? err.message : String(err)}`,
-    }
-  }
-}
-
-export async function executeToolAndReport(
-  toolCallId: string,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options?: OrchestratorOptions
-): Promise<AsyncToolCompletion> {
-  const toolCall = context.toolCalls.get(toolCallId)
-  if (!toolCall) return { status: 'error', message: 'Tool call not found' }
-
-  if (toolCall.status === 'executing') {
-    return { status: 'running', message: 'Tool already executing' }
-  }
-  if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
-    return terminalCompletionFromToolCall(toolCall)
-  }
-
-  if (abortRequested(context, execContext, options)) {
-    toolCall.status = 'cancelled'
-    toolCall.endTime = Date.now()
-    markToolResultSeen(toolCall.id)
-    await completeAsyncToolCall({
-      toolCallId: toolCall.id,
-      status: 'cancelled',
-      result: { cancelled: true },
-      error: 'Request aborted before tool execution',
-    }).catch(() => {})
-    reportCancelledTool(toolCall, 'Request aborted before tool execution', context.messageId)
-    return cancelledCompletion('Request aborted before tool execution')
-  }
-
-  toolCall.status = 'executing'
-  await markAsyncToolRunning(toolCall.id, 'sim-stream').catch(() => {})
-
-  logger.withMetadata({ messageId: context.messageId }).info('Tool execution started', {
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    params: toolCall.params,
-  })
-
-  try {
-    let result = await executeToolServerSide(toolCall, execContext)
-    if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
-      return terminalCompletionFromToolCall(toolCall)
-    }
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool execution',
-      }).catch(() => {})
-      reportCancelledTool(toolCall, 'Request aborted during tool execution', context.messageId)
-      return cancelledCompletion('Request aborted during tool execution')
-    }
-    result = await maybeWriteOutputToFile(toolCall.name, toolCall.params, result, execContext)
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool post-processing',
-      }).catch(() => {})
-      reportCancelledTool(
-        toolCall,
-        'Request aborted during tool post-processing',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted during tool post-processing')
-    }
-    result = await maybeWriteOutputToTable(toolCall.name, toolCall.params, result, execContext)
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool post-processing',
-      }).catch(() => {})
-      reportCancelledTool(
-        toolCall,
-        'Request aborted during tool post-processing',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted during tool post-processing')
-    }
-    result = await maybeWriteReadCsvToTable(toolCall.name, toolCall.params, result, execContext)
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool post-processing',
-      }).catch(() => {})
-      reportCancelledTool(
-        toolCall,
-        'Request aborted during tool post-processing',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted during tool post-processing')
-    }
-    toolCall.status = result.success ? 'success' : 'error'
-    toolCall.result = result
-    toolCall.error = result.error
-    toolCall.endTime = Date.now()
-
-    if (result.success) {
-      const raw = result.output
-      const preview =
-        typeof raw === 'string'
-          ? raw.slice(0, 200)
-          : raw && typeof raw === 'object'
-            ? JSON.stringify(raw).slice(0, 200)
-            : undefined
-      logger.withMetadata({ messageId: context.messageId }).info('Tool execution succeeded', {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        outputPreview: preview,
-      })
-    } else {
-      logger.withMetadata({ messageId: context.messageId }).warn('Tool execution failed', {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        error: result.error,
-        params: toolCall.params,
-      })
-    }
-
-    // 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.
-    const output = asRecord(result.output)
-    if (
-      toolCall.name === 'create_workflow' &&
-      result.success &&
-      output.workflowId &&
-      !execContext.workflowId
-    ) {
-      execContext.workflowId = output.workflowId as string
-      if (output.workspaceId) {
-        execContext.workspaceId = output.workspaceId as string
-      }
-    }
-
-    markToolResultSeen(toolCall.id)
-    await completeAsyncToolCall({
-      toolCallId: toolCall.id,
-      status: result.success ? 'completed' : 'failed',
-      result: result.success ? asRecord(result.output) : { error: result.error || 'Tool failed' },
-      error: result.success ? null : result.error || 'Tool failed',
-    }).catch(() => {})
-
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      reportCancelledTool(
-        toolCall,
-        'Request aborted before tool result delivery',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted before tool result delivery')
-    }
-
-    // Fire-and-forget: notify the copilot backend that the tool completed.
-    // IMPORTANT: We must NOT await this — the server may block on the
-    // mark-complete handler until it can write back on the SSE stream, but
-    // the SSE reader (our for-await loop) is paused while we're in this
-    // handler.  Awaiting here would deadlock: sim waits for the server's response,
-    // the server waits for sim to drain the SSE stream.
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      result.success ? 200 : 500,
-      result.error || (result.success ? 'Tool completed' : 'Tool failed'),
-      result.output,
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed', {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-
-    const resultEvent: SSEEvent = {
-      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,
-      },
-    }
-    await options?.onEvent?.(resultEvent)
-
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      return cancelledCompletion('Request aborted before resource persistence')
-    }
-
-    if (result.success && execContext.chatId && !abortRequested(context, execContext, options)) {
-      let isDeleteOp = false
-
-      if (hasDeleteCapability(toolCall.name)) {
-        const deleted = extractDeletedResourcesFromToolResult(
-          toolCall.name,
-          toolCall.params,
-          result.output
-        )
-        if (deleted.length > 0) {
-          isDeleteOp = true
-          removeChatResources(execContext.chatId, deleted).catch((err) => {
-            logger
-              .withMetadata({ messageId: context.messageId })
-              .warn('Failed to remove chat resources after deletion', {
-                chatId: execContext.chatId,
-                error: err instanceof Error ? err.message : String(err),
-              })
-          })
-
-          for (const resource of deleted) {
-            if (abortRequested(context, execContext, options)) break
-            await options?.onEvent?.({
-              type: 'resource_deleted',
-              resource: { type: resource.type, id: resource.id, title: resource.title },
-            })
-          }
-        }
-      }
-
-      if (!isDeleteOp && !abortRequested(context, execContext, options)) {
-        const resources =
-          result.resources && result.resources.length > 0
-            ? result.resources
-            : isResourceToolName(toolCall.name)
-              ? extractResourcesFromToolResult(toolCall.name, toolCall.params, result.output)
-              : []
-
-        if (resources.length > 0) {
-          persistChatResources(execContext.chatId, resources).catch((err) => {
-            logger
-              .withMetadata({ messageId: context.messageId })
-              .warn('Failed to persist chat resources', {
-                chatId: execContext.chatId,
-                error: err instanceof Error ? err.message : String(err),
-              })
-          })
-
-          for (const resource of resources) {
-            if (abortRequested(context, execContext, options)) break
-            await options?.onEvent?.({
-              type: 'resource_added',
-              resource: { type: resource.type, id: resource.id, title: resource.title },
-            })
-          }
-        }
-      }
-    }
-    return {
-      status: result.success ? 'success' : 'error',
-      message: result.error || (result.success ? 'Tool completed' : 'Tool failed'),
-      data: asRecord(result.output),
-    }
-  } catch (error) {
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool execution',
-      }).catch(() => {})
-      reportCancelledTool(toolCall, 'Request aborted during tool execution', context.messageId)
-      return cancelledCompletion('Request aborted during tool execution')
-    }
-    toolCall.status = 'error'
-    toolCall.error = error instanceof Error ? error.message : String(error)
-    toolCall.endTime = Date.now()
-
-    logger.withMetadata({ messageId: context.messageId }).error('Tool execution threw', {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      error: toolCall.error,
-      params: toolCall.params,
-    })
-
-    markToolResultSeen(toolCall.id)
-    await completeAsyncToolCall({
-      toolCallId: toolCall.id,
-      status: 'failed',
-      result: { error: toolCall.error },
-      error: toolCall.error,
-    }).catch(() => {})
-
-    // Fire-and-forget (same reasoning as above).
-    // Pass error as structured data so the Go side can surface it to the LLM.
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      500,
-      toolCall.error,
-      {
-        error: toolCall.error,
-      },
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed', {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-
-    const errorEvent: SSEEvent = {
-      type: 'tool_error',
-      state: 'error',
-      toolCallId: toolCall.id,
-      data: {
-        id: toolCall.id,
-        name: toolCall.name,
-        error: toolCall.error,
-      },
-    }
-    await options?.onEvent?.(errorEvent)
-    return {
-      status: 'error',
-      message: toolCall.error,
-      data: { error: toolCall.error },
-    }
-  }
-}
-
-/**
- * Wait for a tool completion signal (success/error/rejected) from the client.
- * Ignores intermediate statuses like `accepted` and only returns terminal statuses:
- * - success: client finished executing successfully
- * - error: client execution failed
- * - rejected: user clicked Skip (subagent run tools where user hasn't auto-allowed)
- *
- * Used for client-executable run tools: the client executes the workflow
- * and posts success/error to /api/copilot/confirm when done. The server
- * waits here until that completion signal arrives.
- */
-export async function waitForToolCompletion(
-  toolCallId: string,
-  timeoutMs: number,
-  abortSignal?: AbortSignal
-): Promise<{ status: string; message?: string; data?: Record<string, unknown> } | null> {
-  const decision = await waitForToolConfirmation(toolCallId, timeoutMs, abortSignal, {
-    acceptStatus: (status) =>
-      status === 'success' ||
-      status === 'error' ||
-      status === 'rejected' ||
-      status === 'background' ||
-      status === 'cancelled' ||
-      status === 'delivered',
-  })
-  if (
-    decision?.status === 'success' ||
-    decision?.status === 'error' ||
-    decision?.status === 'rejected' ||
-    decision?.status === 'background' ||
-    decision?.status === 'cancelled' ||
-    decision?.status === 'delivered'
-  ) {
-    return decision
-  }
-  return null
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/utils.test.ts b/apps/sim/lib/copilot/orchestrator/sse/utils.test.ts
deleted file mode 100644
index 56eaad33789..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/utils.test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { describe, expect, it } from 'vitest'
-import {
-  markToolResultSeen,
-  normalizeSseEvent,
-  shouldSkipToolCallEvent,
-  shouldSkipToolResultEvent,
-} from '@/lib/copilot/orchestrator/sse/utils'
-
-describe('sse-utils', () => {
-  it.concurrent('normalizes tool fields from string data', () => {
-    const event = {
-      type: 'tool_result',
-      data: JSON.stringify({
-        id: 'tool_1',
-        name: 'edit_workflow',
-        success: true,
-        result: { ok: true },
-      }),
-    }
-
-    const normalized = normalizeSseEvent(event as any)
-
-    expect(normalized.toolCallId).toBe('tool_1')
-    expect(normalized.toolName).toBe('edit_workflow')
-    expect(normalized.success).toBe(true)
-    expect(normalized.result).toEqual({ ok: true })
-  })
-
-  it.concurrent('dedupes tool_call events', () => {
-    const event = { type: 'tool_call', data: { id: 'tool_call_1', name: 'plan' } }
-    expect(shouldSkipToolCallEvent(event as any)).toBe(false)
-    expect(shouldSkipToolCallEvent(event as any)).toBe(true)
-  })
-
-  it.concurrent('dedupes tool_result events', () => {
-    const event = { type: 'tool_result', data: { id: 'tool_result_1', name: 'plan' } }
-    expect(shouldSkipToolResultEvent(event as any)).toBe(false)
-    markToolResultSeen('tool_result_1')
-    expect(shouldSkipToolResultEvent(event as any)).toBe(true)
-  })
-})
diff --git a/apps/sim/lib/copilot/orchestrator/sse/utils.ts b/apps/sim/lib/copilot/orchestrator/sse/utils.ts
deleted file mode 100644
index 3619012d9f9..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/utils.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-import { STREAM_BUFFER_MAX_DEDUP_ENTRIES } from '@/lib/copilot/constants'
-import type { SSEEvent } from '@/lib/copilot/orchestrator/types'
-
-type EventDataObject = Record<string, unknown> | undefined
-
-/** Safely cast event.data to a record for property access. */
-export const asRecord = (data: unknown): Record<string, unknown> =>
-  (data && typeof data === 'object' && !Array.isArray(data) ? data : {}) as Record<string, unknown>
-
-/**
- * In-memory tool event dedupe with bounded size.
- *
- * NOTE: Process-local only. In a multi-instance setup (e.g., ECS),
- * each task maintains its own dedupe cache.
- */
-const seenToolCalls = new Set<string>()
-const seenToolResults = new Set<string>()
-
-function addToSet(set: Set<string>, id: string): void {
-  if (set.size >= STREAM_BUFFER_MAX_DEDUP_ENTRIES) {
-    const first = set.values().next().value
-    if (first) set.delete(first)
-  }
-  set.add(id)
-}
-
-const parseEventData = (data: unknown): EventDataObject => {
-  if (!data) return undefined
-  if (typeof data !== 'string') {
-    if (typeof data === 'object' && !Array.isArray(data)) {
-      return data as EventDataObject
-    }
-    return undefined
-  }
-  try {
-    const parsed = JSON.parse(data)
-    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-      return parsed as EventDataObject
-    }
-    return undefined
-  } 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
-  )
-}
-
-export 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
-}
-
-function getToolCallIdFromEvent(event: SSEEvent): string | undefined {
-  const data = getEventData(event)
-  return (
-    event.toolCallId || (data?.id as string | undefined) || (data?.toolCallId as string | undefined)
-  )
-}
-
-/** 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 as string | undefined) || (data.toolCallId as string | undefined)
-  const toolName =
-    event.toolName || (data.name as string | undefined) || (data.toolName as string | undefined)
-  const success = event.success ?? (data.success as boolean | undefined)
-  const result = event.result ?? data.result
-  const normalizedData = typeof event.data === 'string' ? data : event.data
-  return {
-    ...event,
-    data: normalizedData,
-    toolCallId,
-    toolName,
-    success,
-    result,
-  }
-}
-
-function markToolCallSeen(toolCallId: string): void {
-  addToSet(seenToolCalls, toolCallId)
-}
-
-function wasToolCallSeen(toolCallId: string): boolean {
-  return seenToolCalls.has(toolCallId)
-}
-
-export function markToolResultSeen(toolCallId: string): void {
-  addToSet(seenToolResults, toolCallId)
-}
-
-export function wasToolResultSeen(toolCallId: string): boolean {
-  return seenToolResults.has(toolCallId)
-}
-
-export function shouldSkipToolCallEvent(event: SSEEvent): boolean {
-  if (event.type !== 'tool_call') return false
-  const toolCallId = getToolCallIdFromEvent(event)
-  if (!toolCallId) return false
-  const eventData = getEventData(event)
-  if (eventData?.partial === true) return false
-  if (wasToolResultSeen(toolCallId) || wasToolCallSeen(toolCallId)) {
-    return true
-  }
-  markToolCallSeen(toolCallId)
-  return false
-}
-
-export function shouldSkipToolResultEvent(event: SSEEvent): boolean {
-  if (event.type !== 'tool_result') return false
-  const toolCallId = getToolCallIdFromEvent(event)
-  if (!toolCallId) return false
-  return wasToolResultSeen(toolCallId)
-}
diff --git a/apps/sim/lib/copilot/orchestrator/stream/buffer.test.ts b/apps/sim/lib/copilot/orchestrator/stream/buffer.test.ts
deleted file mode 100644
index 1a87edbb366..00000000000
--- a/apps/sim/lib/copilot/orchestrator/stream/buffer.test.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { loggerMock } from '@sim/testing'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('@sim/logger', () => loggerMock)
-
-type StoredEntry = { score: number; value: string }
-
-const createRedisStub = () => {
-  const events = new Map<string, StoredEntry[]>()
-  const counters = new Map<string, number>()
-
-  const readEntries = (key: string, min: number, max: number) => {
-    const list = events.get(key) || []
-    return list
-      .filter((entry) => entry.score >= min && entry.score <= max)
-      .sort((a, b) => a.score - b.score)
-      .map((entry) => entry.value)
-  }
-
-  return {
-    del: vi.fn().mockResolvedValue(1),
-    hset: vi.fn().mockResolvedValue(1),
-    hgetall: vi.fn().mockResolvedValue({}),
-    expire: vi.fn().mockResolvedValue(1),
-    eval: vi
-      .fn()
-      .mockImplementation(
-        (
-          _lua: string,
-          _keysCount: number,
-          seqKey: string,
-          eventsKey: string,
-          _ttl: number,
-          _limit: number,
-          streamId: string,
-          eventJson: string
-        ) => {
-          const current = counters.get(seqKey) || 0
-          const next = current + 1
-          counters.set(seqKey, next)
-          const entry = JSON.stringify({ eventId: next, streamId, event: JSON.parse(eventJson) })
-          const list = events.get(eventsKey) || []
-          list.push({ score: next, value: entry })
-          events.set(eventsKey, list)
-          return next
-        }
-      ),
-    incrby: vi.fn().mockImplementation((key: string, amount: number) => {
-      const current = counters.get(key) || 0
-      const next = current + amount
-      counters.set(key, next)
-      return next
-    }),
-    zrangebyscore: vi.fn().mockImplementation((key: string, min: string, max: string) => {
-      const minVal = Number(min)
-      const maxVal = max === '+inf' ? Number.POSITIVE_INFINITY : Number(max)
-      return Promise.resolve(readEntries(key, minVal, maxVal))
-    }),
-    pipeline: vi.fn().mockImplementation(() => {
-      const api: Record<string, any> = {}
-      api.zadd = vi.fn().mockImplementation((key: string, ...args: Array<string | number>) => {
-        const list = events.get(key) || []
-        for (let i = 0; i < args.length; i += 2) {
-          list.push({ score: Number(args[i]), value: String(args[i + 1]) })
-        }
-        events.set(key, list)
-        return api
-      })
-      api.expire = vi.fn().mockReturnValue(api)
-      api.zremrangebyrank = vi.fn().mockReturnValue(api)
-      api.exec = vi.fn().mockResolvedValue([])
-      return api
-    }),
-  }
-}
-
-let mockRedis: ReturnType<typeof createRedisStub>
-
-vi.mock('@/lib/core/config/redis', () => ({
-  getRedisClient: () => mockRedis,
-}))
-
-import {
-  appendStreamEvent,
-  createStreamEventWriter,
-  readStreamEvents,
-} from '@/lib/copilot/orchestrator/stream/buffer'
-
-describe('stream-buffer', () => {
-  beforeEach(() => {
-    mockRedis = createRedisStub()
-    vi.clearAllMocks()
-  })
-
-  it.concurrent('replays events after a given event id', async () => {
-    await appendStreamEvent('stream-1', { type: 'content', data: 'hello' })
-    await appendStreamEvent('stream-1', { type: 'content', data: 'world' })
-
-    const allEvents = await readStreamEvents('stream-1', 0)
-    expect(allEvents.map((entry) => entry.event.data)).toEqual(['hello', 'world'])
-
-    const replayed = await readStreamEvents('stream-1', 1)
-    expect(replayed.map((entry) => entry.event.data)).toEqual(['world'])
-  })
-
-  it.concurrent('flushes buffered events for resume', async () => {
-    const writer = createStreamEventWriter('stream-2')
-    await writer.write({ type: 'content', data: 'a' })
-    await writer.write({ type: 'content', data: 'b' })
-    await writer.flush()
-
-    const events = await readStreamEvents('stream-2', 0)
-    expect(events.map((entry) => entry.event.data)).toEqual(['a', 'b'])
-  })
-})
diff --git a/apps/sim/lib/copilot/orchestrator/stream/buffer.ts b/apps/sim/lib/copilot/orchestrator/stream/buffer.ts
deleted file mode 100644
index 526488c9182..00000000000
--- a/apps/sim/lib/copilot/orchestrator/stream/buffer.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { REDIS_COPILOT_STREAM_PREFIX } from '@/lib/copilot/constants'
-import { env } from '@/lib/core/config/env'
-import { getRedisClient } from '@/lib/core/config/redis'
-
-const logger = createLogger('CopilotStreamBuffer')
-
-const STREAM_DEFAULTS = {
-  ttlSeconds: 60 * 60,
-  eventLimit: 5000,
-  reserveBatch: 200,
-  flushIntervalMs: 15,
-  flushMaxBatch: 200,
-}
-
-export type StreamBufferConfig = {
-  ttlSeconds: number
-  eventLimit: number
-  reserveBatch: number
-  flushIntervalMs: number
-  flushMaxBatch: number
-}
-
-const parseNumber = (value: number | string | undefined, fallback: number): number => {
-  if (typeof value === 'number' && Number.isFinite(value)) return value
-  const parsed = Number(value)
-  return Number.isFinite(parsed) ? parsed : fallback
-}
-
-export function getStreamBufferConfig(): StreamBufferConfig {
-  return {
-    ttlSeconds: parseNumber(env.COPILOT_STREAM_TTL_SECONDS, STREAM_DEFAULTS.ttlSeconds),
-    eventLimit: parseNumber(env.COPILOT_STREAM_EVENT_LIMIT, STREAM_DEFAULTS.eventLimit),
-    reserveBatch: parseNumber(env.COPILOT_STREAM_RESERVE_BATCH, STREAM_DEFAULTS.reserveBatch),
-    flushIntervalMs: parseNumber(
-      env.COPILOT_STREAM_FLUSH_INTERVAL_MS,
-      STREAM_DEFAULTS.flushIntervalMs
-    ),
-    flushMaxBatch: parseNumber(env.COPILOT_STREAM_FLUSH_MAX_BATCH, STREAM_DEFAULTS.flushMaxBatch),
-  }
-}
-
-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 `${REDIS_COPILOT_STREAM_PREFIX}${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' | 'cancelled' | 'error'
-
-export type StreamMeta = {
-  status: StreamStatus
-  userId?: string
-  executionId?: string
-  runId?: string
-  updatedAt?: string
-  error?: string
-}
-
-export type StreamEventEntry = {
-  eventId: number
-  streamId: string
-  event: Record<string, unknown>
-}
-
-export type StreamEventWriter = {
-  write: (event: Record<string, unknown>) => 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 config = getStreamBufferConfig()
-    const payload: Record<string, string> = {
-      status: meta.status,
-      updatedAt: meta.updatedAt || new Date().toISOString(),
-    }
-    if (meta.userId) payload.userId = meta.userId
-    if (meta.executionId) payload.executionId = meta.executionId
-    if (meta.runId) payload.runId = meta.runId
-    if (meta.error) payload.error = meta.error
-    await redis.hset(getMetaKey(streamId), payload)
-    await redis.expire(getMetaKey(streamId), config.ttlSeconds)
-  } 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, unknown>
-): Promise<StreamEventEntry> {
-  const redis = getRedisClient()
-  if (!redis) {
-    return { eventId: 0, streamId, event }
-  }
-
-  try {
-    const config = getStreamBufferConfig()
-    const eventJson = JSON.stringify(event)
-    const nextId = await redis.eval(
-      APPEND_STREAM_EVENT_LUA,
-      2,
-      getSeqKey(streamId),
-      getEventsKey(streamId),
-      config.ttlSeconds,
-      config.eventLimit,
-      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 () => {},
-    }
-  }
-
-  const config = getStreamBufferConfig()
-  let pending: StreamEventEntry[] = []
-  let nextEventId = 0
-  let maxReservedId = 0
-  let flushTimer: ReturnType<typeof setTimeout> | null = null
-  const scheduleFlush = () => {
-    if (flushTimer) return
-    flushTimer = setTimeout(() => {
-      flushTimer = null
-      void flush()
-    }, config.flushIntervalMs)
-  }
-
-  const reserveIds = async (minCount: number) => {
-    const reserveCount = Math.max(config.reserveBatch, minCount)
-    const newMax = await redis.incrby(getSeqKey(streamId), reserveCount)
-    const startId = newMax - reserveCount + 1
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      nextEventId = startId
-      maxReservedId = newMax
-    }
-  }
-
-  let flushPromise: Promise<void> | null = null
-  let closed = false
-
-  const doFlush = async () => {
-    if (pending.length === 0) return
-    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 [number, string]))
-      pipeline.expire(key, config.ttlSeconds)
-      pipeline.expire(getSeqKey(streamId), config.ttlSeconds)
-      pipeline.zremrangebyrank(key, 0, -config.eventLimit - 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)
-      if (pending.length > config.eventLimit) {
-        const dropped = pending.length - config.eventLimit
-        pending = pending.slice(-config.eventLimit)
-        logger.warn('Dropped oldest pending stream events due to sustained Redis failure', {
-          streamId,
-          dropped,
-          remaining: pending.length,
-        })
-      }
-    }
-  }
-
-  const flush = async () => {
-    if (flushPromise) {
-      await flushPromise
-      return
-    }
-    flushPromise = doFlush()
-    try {
-      await flushPromise
-    } finally {
-      flushPromise = null
-      if (pending.length > 0) scheduleFlush()
-    }
-  }
-
-  const write = async (event: Record<string, unknown>) => {
-    if (closed) return { eventId: 0, streamId, event }
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      await reserveIds(1)
-    }
-    const eventId = nextEventId++
-    const entry: StreamEventEntry = { eventId, streamId, event }
-    pending.push(entry)
-    if (pending.length >= config.flushMaxBatch) {
-      await flush()
-    } else {
-      scheduleFlush()
-    }
-    return entry
-  }
-
-  const close = async () => {
-    closed = true
-    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 []
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/stream/core.ts b/apps/sim/lib/copilot/orchestrator/stream/core.ts
deleted file mode 100644
index 43c0bc342c9..00000000000
--- a/apps/sim/lib/copilot/orchestrator/stream/core.ts
+++ /dev/null
@@ -1,265 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
-import { isPaid } from '@/lib/billing/plan-helpers'
-import { ORCHESTRATION_TIMEOUT_MS } from '@/lib/copilot/constants'
-import {
-  handleSubagentRouting,
-  sseHandlers,
-  subAgentHandlers,
-} from '@/lib/copilot/orchestrator/sse/handlers'
-import { parseSSEStream } from '@/lib/copilot/orchestrator/sse/parser'
-import {
-  normalizeSseEvent,
-  shouldSkipToolCallEvent,
-  shouldSkipToolResultEvent,
-} from '@/lib/copilot/orchestrator/sse/utils'
-import type {
-  ExecutionContext,
-  OrchestratorOptions,
-  SSEEvent,
-  StreamingContext,
-  ToolCallSummary,
-} from '@/lib/copilot/orchestrator/types'
-import { generateId } from '@/lib/core/utils/uuid'
-
-const logger = createLogger('CopilotStreamCore')
-
-/**
- * Options for the shared stream processing loop.
- */
-export interface StreamLoopOptions extends OrchestratorOptions {
-  /**
-   * Called for each normalized event BEFORE standard handler dispatch.
-   * Return true to skip the default handler for this event.
-   */
-  onBeforeDispatch?: (event: SSEEvent, context: StreamingContext) => boolean | undefined
-}
-
-/**
- * Create a fresh StreamingContext.
- */
-export function createStreamingContext(overrides?: Partial<StreamingContext>): StreamingContext {
-  return {
-    chatId: undefined,
-    executionId: undefined,
-    runId: undefined,
-    messageId: generateId(),
-    accumulatedContent: '',
-    contentBlocks: [],
-    toolCalls: new Map(),
-    pendingToolPromises: new Map(),
-    currentThinkingBlock: null,
-    isInThinkingBlock: false,
-    subAgentParentToolCallId: undefined,
-    subAgentParentStack: [],
-    subAgentContent: {},
-    subAgentToolCalls: {},
-    pendingContent: '',
-    streamComplete: false,
-    wasAborted: false,
-    errors: [],
-    ...overrides,
-  }
-}
-
-/**
- * Run the SSE stream processing loop.
- *
- * Handles: fetch -> parse -> normalize -> dedupe -> subagent routing -> handler dispatch.
- * Callers provide the fetch URL/options and can intercept events via onBeforeDispatch.
- */
-export async function runStreamLoop(
-  fetchUrl: string,
-  fetchOptions: RequestInit,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options: StreamLoopOptions
-): Promise<void> {
-  const { timeout = ORCHESTRATION_TIMEOUT_MS, abortSignal } = options
-
-  const response = await fetch(fetchUrl, {
-    ...fetchOptions,
-    signal: abortSignal,
-  })
-
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => '')
-
-    if (response.status === 402) {
-      let action = 'upgrade_plan'
-      let message = "You've reached your usage limit. Please upgrade your plan to continue."
-      try {
-        const sub = await getHighestPrioritySubscription(execContext.userId)
-        if (sub && isPaid(sub.plan)) {
-          action = 'increase_limit'
-          message =
-            "You've reached your usage limit for this billing period. Please increase your usage limit to continue."
-        }
-      } catch {
-        // Fall back to upgrade_plan if we can't determine the plan
-      }
-
-      const upgradePayload = JSON.stringify({
-        reason: 'usage_limit',
-        action,
-        message,
-      })
-      const syntheticContent = `<usage_upgrade>${upgradePayload}</usage_upgrade>`
-
-      const syntheticEvents: SSEEvent[] = [
-        { type: 'content', data: syntheticContent as unknown as Record<string, unknown> },
-        { type: 'done', data: {} },
-      ]
-      for (const event of syntheticEvents) {
-        try {
-          await options.onEvent?.(event)
-        } catch {
-          // best-effort forwarding
-        }
-
-        const handler = sseHandlers[event.type]
-        if (handler) {
-          await handler(event, context, execContext, options)
-        }
-        if (context.streamComplete) break
-      }
-      return
-    }
-
-    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
-        await reader.cancel().catch(() => {})
-        break
-      }
-
-      const normalizedEvent = normalizeSseEvent(event)
-
-      // Skip duplicate tool events — both forwarding AND handler dispatch.
-      const shouldSkipToolCall = shouldSkipToolCallEvent(normalizedEvent)
-      const shouldSkipToolResult = shouldSkipToolResultEvent(normalizedEvent)
-
-      if (shouldSkipToolCall || shouldSkipToolResult) {
-        continue
-      }
-
-      try {
-        await options.onEvent?.(normalizedEvent)
-      } catch (error) {
-        logger.withMetadata({ messageId: context.messageId }).warn('Failed to forward SSE event', {
-          type: normalizedEvent.type,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-
-      // Let the caller intercept before standard dispatch.
-      if (options.onBeforeDispatch?.(normalizedEvent, context)) {
-        if (context.streamComplete) break
-        continue
-      }
-
-      // Standard subagent start/end handling (stack-based for nested agents).
-      if (normalizedEvent.type === 'subagent_start') {
-        const eventData = normalizedEvent.data as Record<string, unknown> | undefined
-        const toolCallId = eventData?.tool_call_id as string | undefined
-        const subagentName = normalizedEvent.subagent || (eventData?.agent as string | undefined)
-        if (toolCallId) {
-          context.subAgentParentStack.push(toolCallId)
-          context.subAgentParentToolCallId = toolCallId
-          context.subAgentContent[toolCallId] = ''
-          context.subAgentToolCalls[toolCallId] = []
-        }
-        if (subagentName) {
-          context.contentBlocks.push({
-            type: 'subagent',
-            content: subagentName,
-            timestamp: Date.now(),
-          })
-        }
-        continue
-      }
-
-      if (normalizedEvent.type === 'subagent_end') {
-        if (context.subAgentParentStack.length > 0) {
-          context.subAgentParentStack.pop()
-        } else {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('subagent_end without matching subagent_start')
-        }
-        context.subAgentParentToolCallId =
-          context.subAgentParentStack.length > 0
-            ? context.subAgentParentStack[context.subAgentParentStack.length - 1]
-            : undefined
-        continue
-      }
-
-      // Subagent event routing.
-      if (handleSubagentRouting(normalizedEvent, context)) {
-        const handler = subAgentHandlers[normalizedEvent.type]
-        if (handler) {
-          await handler(normalizedEvent, context, execContext, options)
-        }
-        if (context.streamComplete) break
-        continue
-      }
-
-      // Main event handler dispatch.
-      const handler = sseHandlers[normalizedEvent.type]
-      if (handler) {
-        await handler(normalizedEvent, context, execContext, options)
-      }
-      if (context.streamComplete) break
-    }
-  } finally {
-    if (abortSignal?.aborted) {
-      context.wasAborted = true
-      await reader.cancel().catch(() => {})
-    }
-    clearTimeout(timeoutId)
-  }
-}
-
-/**
- * Build a ToolCallSummary array from the streaming context.
- */
-export function buildToolCallSummaries(context: StreamingContext): ToolCallSummary[] {
-  return Array.from(context.toolCalls.values()).map((toolCall) => {
-    let status = toolCall.status
-    if (toolCall.result && toolCall.result.success !== undefined) {
-      status = toolCall.result.success ? 'success' : 'error'
-    } else if ((status === 'pending' || status === 'executing') && toolCall.error) {
-      status = 'error'
-    }
-
-    return {
-      id: toolCall.id,
-      name: toolCall.name,
-      status,
-      params: toolCall.params,
-      result: toolCall.result?.output,
-      error: toolCall.error,
-      durationMs:
-        toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
-    }
-  })
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/index.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/index.ts
deleted file mode 100644
index 9e490922b12..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './deploy'
-export * from './manage'
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/index.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/index.ts
deleted file mode 100644
index 5cbbcdd5730..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/index.ts
+++ /dev/null
@@ -1,1514 +0,0 @@
-import { db } from '@sim/db'
-import { credential, mcpServers, pendingCredentialDraft, user } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, eq, isNull, lt } from 'drizzle-orm'
-import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import type {
-  ExecutionContext,
-  ToolCallResult,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { routeExecution } from '@/lib/copilot/tools/server/router'
-import { env } from '@/lib/core/config/env'
-import { getBaseUrl } from '@/lib/core/utils/urls'
-import { generateId } from '@/lib/core/utils/uuid'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { getKnowledgeBaseById } from '@/lib/knowledge/service'
-import { validateMcpDomain } from '@/lib/mcp/domain-check'
-import { mcpService } from '@/lib/mcp/service'
-import { generateMcpServerId } from '@/lib/mcp/utils'
-import { getAllOAuthServices } from '@/lib/oauth/utils'
-import { getTableById } from '@/lib/table/service'
-import { getWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-import {
-  deleteCustomTool,
-  getCustomToolById,
-  listCustomTools,
-  upsertCustomTools,
-} from '@/lib/workflows/custom-tools/operations'
-import { deleteSkill, listSkills, upsertSkills } from '@/lib/workflows/skills/operations'
-import { getWorkflowById } from '@/lib/workflows/utils'
-import { isMcpTool, isUuid } from '@/executor/constants'
-import { executeTool } from '@/tools'
-import { getTool, resolveToolId } from '@/tools/utils'
-import {
-  executeCheckDeploymentStatus,
-  executeCreateWorkspaceMcpServer,
-  executeDeleteWorkspaceMcpServer,
-  executeDeployApi,
-  executeDeployChat,
-  executeDeployMcp,
-  executeGetDeploymentVersion,
-  executeListWorkspaceMcpServers,
-  executeRedeploy,
-  executeRevertToVersion,
-  executeUpdateWorkspaceMcpServer,
-} from './deployment-tools'
-import { executeIntegrationToolDirect } from './integration-tools'
-import {
-  executeCompleteJob,
-  executeCreateJob,
-  executeManageJob,
-  executeUpdateJobHistory,
-} from './job-tools'
-import { executeMaterializeFile } from './materialize-file'
-import type {
-  CheckDeploymentStatusParams,
-  CreateFolderParams,
-  CreateWorkflowParams,
-  CreateWorkspaceMcpServerParams,
-  DeleteFolderParams,
-  DeleteWorkflowParams,
-  DeleteWorkspaceMcpServerParams,
-  DeployApiParams,
-  DeployChatParams,
-  DeployMcpParams,
-  GenerateApiKeyParams,
-  GetBlockOutputsParams,
-  GetBlockUpstreamReferencesParams,
-  GetDeployedWorkflowStateParams,
-  GetWorkflowDataParams,
-  ListFoldersParams,
-  ListWorkspaceMcpServersParams,
-  MoveFolderParams,
-  MoveWorkflowParams,
-  OpenResourceParams,
-  OpenResourceType,
-  RenameFolderParams,
-  RenameWorkflowParams,
-  RunBlockParams,
-  RunFromBlockParams,
-  RunWorkflowParams,
-  RunWorkflowUntilBlockParams,
-  SetGlobalWorkflowVariablesParams,
-  UpdateWorkflowParams,
-  UpdateWorkspaceMcpServerParams,
-  ValidOpenResourceParams,
-} from './param-types'
-import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
-import { executeVfsGlob, executeVfsGrep, executeVfsList, executeVfsRead } from './vfs-tools'
-import {
-  executeCreateFolder,
-  executeCreateWorkflow,
-  executeDeleteFolder,
-  executeDeleteWorkflow,
-  executeGenerateApiKey,
-  executeGetBlockOutputs,
-  executeGetBlockUpstreamReferences,
-  executeGetDeployedWorkflowState,
-  executeGetWorkflowData,
-  executeListFolders,
-  executeListUserWorkspaces,
-  executeMoveFolder,
-  executeMoveWorkflow,
-  executeRenameFolder,
-  executeRenameWorkflow,
-  executeRunBlock,
-  executeRunFromBlock,
-  executeRunWorkflow,
-  executeRunWorkflowUntilBlock,
-  executeSetGlobalWorkflowVariables,
-  executeUpdateWorkflow,
-} from './workflow-tools'
-
-const logger = createLogger('CopilotToolExecutor')
-const VALID_OPEN_RESOURCE_TYPES = new Set<OpenResourceType>([
-  'workflow',
-  'table',
-  'knowledgebase',
-  'file',
-])
-
-function validateOpenResourceParams(
-  params: OpenResourceParams
-): { success: true; params: ValidOpenResourceParams } | { success: false; error: string } {
-  if (!params.type) {
-    return { success: false, error: 'type is required' }
-  }
-
-  if (!VALID_OPEN_RESOURCE_TYPES.has(params.type)) {
-    return { success: false, error: `Invalid resource type: ${params.type}` }
-  }
-
-  if (!params.id) {
-    return { success: false, error: `${params.type} resources require \`id\`` }
-  }
-
-  return {
-    success: true,
-    params: {
-      type: params.type,
-      id: params.id,
-    },
-  }
-}
-
-type ManageCustomToolOperation = 'add' | 'edit' | 'delete' | 'list'
-
-interface ManageCustomToolSchema {
-  type: 'function'
-  function: {
-    name: string
-    description?: string
-    parameters: Record<string, unknown>
-  }
-}
-
-interface ManageCustomToolParams {
-  operation?: string
-  toolId?: string
-  schema?: ManageCustomToolSchema
-  code?: string
-  title?: string
-  workspaceId?: string
-}
-
-async function executeManageCustomTool(
-  rawParams: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const params = rawParams as ManageCustomToolParams
-  const operation = String(params.operation || '').toLowerCase() as ManageCustomToolOperation
-  const workspaceId = params.workspaceId || context.workspaceId
-
-  if (!operation) {
-    return { success: false, error: "Missing required 'operation' argument" }
-  }
-
-  const writeOps: string[] = ['add', 'edit', 'delete']
-  if (
-    writeOps.includes(operation) &&
-    context.userPermission &&
-    context.userPermission !== 'write' &&
-    context.userPermission !== 'admin'
-  ) {
-    return {
-      success: false,
-      error: `Permission denied: '${operation}' on manage_custom_tool requires write access. You have '${context.userPermission}' permission.`,
-    }
-  }
-
-  try {
-    if (operation === 'list') {
-      const toolsForUser = await listCustomTools({
-        userId: context.userId,
-        workspaceId,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          tools: toolsForUser,
-          count: toolsForUser.length,
-        },
-      }
-    }
-
-    if (operation === 'add') {
-      if (!workspaceId) {
-        return {
-          success: false,
-          error: "workspaceId is required for operation 'add'",
-        }
-      }
-      if (!params.schema || !params.code) {
-        return {
-          success: false,
-          error: "Both 'schema' and 'code' are required for operation 'add'",
-        }
-      }
-
-      const title = params.title || params.schema.function?.name
-      if (!title) {
-        return { success: false, error: "Missing tool title or schema.function.name for 'add'" }
-      }
-
-      const resultTools = await upsertCustomTools({
-        tools: [{ title, schema: params.schema, code: params.code }],
-        workspaceId,
-        userId: context.userId,
-      })
-      const created = resultTools.find((tool) => tool.title === title)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.CUSTOM_TOOL_CREATED,
-        resourceType: AuditResourceType.CUSTOM_TOOL,
-        resourceId: created?.id,
-        resourceName: title,
-        description: `Created custom tool "${title}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          toolId: created?.id,
-          title,
-          message: `Created custom tool "${title}"`,
-        },
-      }
-    }
-
-    if (operation === 'edit') {
-      if (!workspaceId) {
-        return {
-          success: false,
-          error: "workspaceId is required for operation 'edit'",
-        }
-      }
-      if (!params.toolId) {
-        return { success: false, error: "'toolId' is required for operation 'edit'" }
-      }
-      if (!params.schema && !params.code) {
-        return {
-          success: false,
-          error: "At least one of 'schema' or 'code' is required for operation 'edit'",
-        }
-      }
-
-      const existing = await getCustomToolById({
-        toolId: params.toolId,
-        userId: context.userId,
-        workspaceId,
-      })
-      if (!existing) {
-        return { success: false, error: `Custom tool not found: ${params.toolId}` }
-      }
-
-      const mergedSchema = params.schema || (existing.schema as ManageCustomToolSchema)
-      const mergedCode = params.code || existing.code
-      const title = params.title || mergedSchema.function?.name || existing.title
-
-      await upsertCustomTools({
-        tools: [{ id: params.toolId, title, schema: mergedSchema, code: mergedCode }],
-        workspaceId,
-        userId: context.userId,
-      })
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.CUSTOM_TOOL_UPDATED,
-        resourceType: AuditResourceType.CUSTOM_TOOL,
-        resourceId: params.toolId,
-        resourceName: title,
-        description: `Updated custom tool "${title}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          toolId: params.toolId,
-          title,
-          message: `Updated custom tool "${title}"`,
-        },
-      }
-    }
-
-    if (operation === 'delete') {
-      if (!params.toolId) {
-        return { success: false, error: "'toolId' is required for operation 'delete'" }
-      }
-
-      const deleted = await deleteCustomTool({
-        toolId: params.toolId,
-        userId: context.userId,
-        workspaceId,
-      })
-      if (!deleted) {
-        return { success: false, error: `Custom tool not found: ${params.toolId}` }
-      }
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.CUSTOM_TOOL_DELETED,
-        resourceType: AuditResourceType.CUSTOM_TOOL,
-        resourceId: params.toolId,
-        description: 'Deleted custom tool',
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          toolId: params.toolId,
-          message: 'Deleted custom tool',
-        },
-      }
-    }
-
-    return {
-      success: false,
-      error: `Unsupported operation for manage_custom_tool: ${operation}`,
-    }
-  } catch (error) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('manage_custom_tool execution failed', {
-        operation,
-        workspaceId,
-        userId: context.userId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to manage custom tool',
-    }
-  }
-}
-
-type ManageMcpToolOperation = 'add' | 'edit' | 'delete' | 'list'
-
-interface ManageMcpToolConfig {
-  name?: string
-  transport?: string
-  url?: string
-  headers?: Record<string, string>
-  timeout?: number
-  enabled?: boolean
-}
-
-interface ManageMcpToolParams {
-  operation?: string
-  serverId?: string
-  config?: ManageMcpToolConfig
-}
-
-async function executeManageMcpTool(
-  rawParams: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const params = rawParams as ManageMcpToolParams
-  const operation = String(params.operation || '').toLowerCase() as ManageMcpToolOperation
-  const workspaceId = context.workspaceId
-
-  if (!operation) {
-    return { success: false, error: "Missing required 'operation' argument" }
-  }
-
-  if (!workspaceId) {
-    return { success: false, error: 'workspaceId is required' }
-  }
-
-  const writeOps: string[] = ['add', 'edit', 'delete']
-  if (
-    writeOps.includes(operation) &&
-    context.userPermission &&
-    context.userPermission !== 'write' &&
-    context.userPermission !== 'admin'
-  ) {
-    return {
-      success: false,
-      error: `Permission denied: '${operation}' on manage_mcp_tool requires write access. You have '${context.userPermission}' permission.`,
-    }
-  }
-
-  try {
-    if (operation === 'list') {
-      const servers = await db
-        .select()
-        .from(mcpServers)
-        .where(and(eq(mcpServers.workspaceId, workspaceId), isNull(mcpServers.deletedAt)))
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          servers: servers.map((s) => ({
-            id: s.id,
-            name: s.name,
-            url: s.url,
-            transport: s.transport,
-            enabled: s.enabled,
-            connectionStatus: s.connectionStatus,
-          })),
-          count: servers.length,
-        },
-      }
-    }
-
-    if (operation === 'add') {
-      const config = params.config
-      if (!config?.name || !config?.url) {
-        return { success: false, error: "config.name and config.url are required for 'add'" }
-      }
-
-      validateMcpDomain(config.url)
-
-      const serverId = generateMcpServerId(workspaceId, config.url)
-
-      const [existing] = await db
-        .select({ id: mcpServers.id, deletedAt: mcpServers.deletedAt })
-        .from(mcpServers)
-        .where(and(eq(mcpServers.id, serverId), eq(mcpServers.workspaceId, workspaceId)))
-        .limit(1)
-
-      if (existing) {
-        await db
-          .update(mcpServers)
-          .set({
-            name: config.name,
-            transport: config.transport || 'streamable-http',
-            url: config.url,
-            headers: config.headers || {},
-            timeout: config.timeout || 30000,
-            enabled: config.enabled !== false,
-            connectionStatus: 'connected',
-            lastConnected: new Date(),
-            updatedAt: new Date(),
-            deletedAt: null,
-          })
-          .where(eq(mcpServers.id, serverId))
-      } else {
-        await db.insert(mcpServers).values({
-          id: serverId,
-          workspaceId,
-          createdBy: context.userId,
-          name: config.name,
-          description: '',
-          transport: config.transport || 'streamable-http',
-          url: config.url,
-          headers: config.headers || {},
-          timeout: config.timeout || 30000,
-          retries: 3,
-          enabled: config.enabled !== false,
-          connectionStatus: 'connected',
-          lastConnected: new Date(),
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        })
-      }
-
-      await mcpService.clearCache(workspaceId)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_ADDED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: serverId,
-        resourceName: config.name,
-        description: existing
-          ? `Updated existing MCP server "${config.name}"`
-          : `Added MCP server "${config.name}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          serverId,
-          name: config.name,
-          message: existing
-            ? `Updated existing MCP server "${config.name}"`
-            : `Added MCP server "${config.name}"`,
-        },
-      }
-    }
-
-    if (operation === 'edit') {
-      if (!params.serverId) {
-        return { success: false, error: "'serverId' is required for 'edit'" }
-      }
-      const config = params.config
-      if (!config) {
-        return { success: false, error: "'config' is required for 'edit'" }
-      }
-
-      if (config.url) {
-        validateMcpDomain(config.url)
-      }
-
-      const updateData: Record<string, unknown> = { updatedAt: new Date() }
-      if (config.name !== undefined) updateData.name = config.name
-      if (config.transport !== undefined) updateData.transport = config.transport
-      if (config.url !== undefined) updateData.url = config.url
-      if (config.headers !== undefined) updateData.headers = config.headers
-      if (config.timeout !== undefined) updateData.timeout = config.timeout
-      if (config.enabled !== undefined) updateData.enabled = config.enabled
-
-      const [updated] = await db
-        .update(mcpServers)
-        .set(updateData)
-        .where(
-          and(
-            eq(mcpServers.id, params.serverId),
-            eq(mcpServers.workspaceId, workspaceId),
-            isNull(mcpServers.deletedAt)
-          )
-        )
-        .returning()
-
-      if (!updated) {
-        return { success: false, error: `MCP server not found: ${params.serverId}` }
-      }
-
-      await mcpService.clearCache(workspaceId)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_UPDATED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: params.serverId,
-        description: `Updated MCP server "${updated.name}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          serverId: params.serverId,
-          name: updated.name,
-          message: `Updated MCP server "${updated.name}"`,
-        },
-      }
-    }
-
-    if (operation === 'delete') {
-      if (context.userPermission && context.userPermission !== 'admin') {
-        return {
-          success: false,
-          error: `Permission denied: 'delete' on manage_mcp_tool requires admin access. You have '${context.userPermission}' permission.`,
-        }
-      }
-
-      if (!params.serverId) {
-        return { success: false, error: "'serverId' is required for 'delete'" }
-      }
-
-      const [deleted] = await db
-        .delete(mcpServers)
-        .where(and(eq(mcpServers.id, params.serverId), eq(mcpServers.workspaceId, workspaceId)))
-        .returning()
-
-      if (!deleted) {
-        return { success: false, error: `MCP server not found: ${params.serverId}` }
-      }
-
-      await mcpService.clearCache(workspaceId)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_REMOVED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: params.serverId,
-        description: `Deleted MCP server "${deleted.name}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          serverId: params.serverId,
-          message: `Deleted MCP server "${deleted.name}"`,
-        },
-      }
-    }
-
-    return { success: false, error: `Unsupported operation for manage_mcp_tool: ${operation}` }
-  } catch (error) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('manage_mcp_tool execution failed', {
-        operation,
-        workspaceId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to manage MCP server',
-    }
-  }
-}
-
-type ManageSkillOperation = 'add' | 'edit' | 'delete' | 'list'
-
-interface ManageSkillParams {
-  operation?: string
-  skillId?: string
-  name?: string
-  description?: string
-  content?: string
-}
-
-async function executeManageSkill(
-  rawParams: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const params = rawParams as ManageSkillParams
-  const operation = String(params.operation || '').toLowerCase() as ManageSkillOperation
-  const workspaceId = context.workspaceId
-
-  if (!operation) {
-    return { success: false, error: "Missing required 'operation' argument" }
-  }
-
-  if (!workspaceId) {
-    return { success: false, error: 'workspaceId is required' }
-  }
-
-  const writeOps: string[] = ['add', 'edit', 'delete']
-  if (
-    writeOps.includes(operation) &&
-    context.userPermission &&
-    context.userPermission !== 'write' &&
-    context.userPermission !== 'admin'
-  ) {
-    return {
-      success: false,
-      error: `Permission denied: '${operation}' on manage_skill requires write access. You have '${context.userPermission}' permission.`,
-    }
-  }
-
-  try {
-    if (operation === 'list') {
-      const skills = await listSkills({ workspaceId })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skills: skills.map((s) => ({
-            id: s.id,
-            name: s.name,
-            description: s.description,
-            createdAt: s.createdAt,
-          })),
-          count: skills.length,
-        },
-      }
-    }
-
-    if (operation === 'add') {
-      if (!params.name || !params.description || !params.content) {
-        return {
-          success: false,
-          error: "'name', 'description', and 'content' are required for 'add'",
-        }
-      }
-
-      const resultSkills = await upsertSkills({
-        skills: [{ name: params.name, description: params.description, content: params.content }],
-        workspaceId,
-        userId: context.userId,
-      })
-      const created = resultSkills.find((s) => s.name === params.name)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.SKILL_CREATED,
-        resourceType: AuditResourceType.SKILL,
-        resourceId: created?.id,
-        resourceName: params.name,
-        description: `Created skill "${params.name}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skillId: created?.id,
-          name: params.name,
-          message: `Created skill "${params.name}"`,
-        },
-      }
-    }
-
-    if (operation === 'edit') {
-      if (!params.skillId) {
-        return { success: false, error: "'skillId' is required for 'edit'" }
-      }
-      if (!params.name && !params.description && !params.content) {
-        return {
-          success: false,
-          error: "At least one of 'name', 'description', or 'content' is required for 'edit'",
-        }
-      }
-
-      const existing = await listSkills({ workspaceId })
-      const found = existing.find((s) => s.id === params.skillId)
-      if (!found) {
-        return { success: false, error: `Skill not found: ${params.skillId}` }
-      }
-
-      await upsertSkills({
-        skills: [
-          {
-            id: params.skillId,
-            name: params.name || found.name,
-            description: params.description || found.description,
-            content: params.content || found.content,
-          },
-        ],
-        workspaceId,
-        userId: context.userId,
-      })
-
-      const updatedName = params.name || found.name
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.SKILL_UPDATED,
-        resourceType: AuditResourceType.SKILL,
-        resourceId: params.skillId,
-        resourceName: updatedName,
-        description: `Updated skill "${updatedName}"`,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skillId: params.skillId,
-          name: updatedName,
-          message: `Updated skill "${updatedName}"`,
-        },
-      }
-    }
-
-    if (operation === 'delete') {
-      if (!params.skillId) {
-        return { success: false, error: "'skillId' is required for 'delete'" }
-      }
-
-      const deleted = await deleteSkill({ skillId: params.skillId, workspaceId })
-      if (!deleted) {
-        return { success: false, error: `Skill not found: ${params.skillId}` }
-      }
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.SKILL_DELETED,
-        resourceType: AuditResourceType.SKILL,
-        resourceId: params.skillId,
-        description: 'Deleted skill',
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skillId: params.skillId,
-          message: 'Deleted skill',
-        },
-      }
-    }
-
-    return { success: false, error: `Unsupported operation for manage_skill: ${operation}` }
-  } catch (error) {
-    logger.withMetadata({ messageId: context.messageId }).error('manage_skill execution failed', {
-      operation,
-      workspaceId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to manage skill',
-    }
-  }
-}
-
-const SERVER_TOOLS = new Set<string>([
-  'get_blocks_metadata',
-  'get_trigger_blocks',
-  'edit_workflow',
-  'get_workflow_logs',
-  'search_documentation',
-  'set_environment_variables',
-  'make_api_request',
-  'knowledge_base',
-  'user_table',
-  'workspace_file',
-  'download_to_workspace_file',
-  'get_execution_summary',
-  'get_job_logs',
-  'generate_visualization',
-  'generate_image',
-])
-
-/**
- * Resolves a human-friendly provider name to a providerId and generates the
- * actual OAuth authorization URL via Better Auth's server-side API.
- *
- * Steps: resolve provider → create credential draft → look up user session →
- * call auth.api.oAuth2LinkAccount → return the real authorization URL.
- */
-async function generateOAuthLink(
-  userId: string,
-  workspaceId: string | undefined,
-  workflowId: string | undefined,
-  chatId: string | undefined,
-  providerName: string,
-  baseUrl: string
-): Promise<{ url: string; providerId: string; serviceName: string }> {
-  if (!workspaceId) {
-    throw new Error('workspaceId is required to generate an OAuth link')
-  }
-
-  const allServices = getAllOAuthServices()
-  const normalizedInput = providerName.toLowerCase().trim()
-
-  const matched =
-    allServices.find((s) => s.providerId === normalizedInput) ||
-    allServices.find((s) => s.name.toLowerCase() === normalizedInput) ||
-    allServices.find(
-      (s) =>
-        s.name.toLowerCase().includes(normalizedInput) ||
-        normalizedInput.includes(s.name.toLowerCase())
-    ) ||
-    allServices.find(
-      (s) => s.providerId.includes(normalizedInput) || normalizedInput.includes(s.providerId)
-    )
-
-  if (!matched) {
-    const available = allServices.map((s) => s.name).join(', ')
-    throw new Error(`Provider "${providerName}" not found. Available providers: ${available}`)
-  }
-
-  const { providerId, name: serviceName } = matched
-  const callbackURL =
-    workflowId && workspaceId
-      ? `${baseUrl}/workspace/${workspaceId}/w/${workflowId}`
-      : chatId && workspaceId
-        ? `${baseUrl}/workspace/${workspaceId}/task/${chatId}`
-        : `${baseUrl}/workspace/${workspaceId}`
-
-  // Trello and Shopify use custom auth routes, not genericOAuth
-  if (providerId === 'trello') {
-    return { url: `${baseUrl}/api/auth/trello/authorize`, providerId, serviceName }
-  }
-  if (providerId === 'shopify') {
-    const returnUrl = encodeURIComponent(callbackURL)
-    return {
-      url: `${baseUrl}/api/auth/shopify/authorize?returnUrl=${returnUrl}`,
-      providerId,
-      serviceName,
-    }
-  }
-
-  // Build display name: "User Name's ServiceName" or just "ServiceName"
-  let displayName = serviceName
-  try {
-    const [row] = await db.select({ name: user.name }).from(user).where(eq(user.id, userId))
-    if (row?.name) {
-      displayName = `${row.name}'s ${serviceName}`
-    }
-  } catch {
-    // Fall back to service name only
-  }
-
-  // Create credential draft so the callback hook creates the credential
-  const now = new Date()
-  await db
-    .delete(pendingCredentialDraft)
-    .where(
-      and(eq(pendingCredentialDraft.userId, userId), lt(pendingCredentialDraft.expiresAt, now))
-    )
-  await db
-    .insert(pendingCredentialDraft)
-    .values({
-      id: generateId(),
-      userId,
-      workspaceId,
-      providerId,
-      displayName,
-      expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
-      createdAt: now,
-    })
-    .onConflictDoUpdate({
-      target: [
-        pendingCredentialDraft.userId,
-        pendingCredentialDraft.providerId,
-        pendingCredentialDraft.workspaceId,
-      ],
-      set: {
-        displayName,
-        expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
-        createdAt: now,
-      },
-    })
-
-  const { auth } = await import('@/lib/auth/auth')
-  const { headers: getHeaders } = await import('next/headers')
-  const reqHeaders = await getHeaders()
-
-  const data = await auth.api.oAuth2LinkAccount({
-    body: { providerId, callbackURL },
-    headers: reqHeaders,
-  })
-
-  if (!data?.url) {
-    throw new Error('oAuth2LinkAccount did not return an authorization URL')
-  }
-
-  return { url: data.url, providerId, serviceName }
-}
-
-const SIM_WORKFLOW_TOOL_HANDLERS: Record<
-  string,
-  (params: Record<string, unknown>, context: ExecutionContext) => Promise<ToolCallResult>
-> = {
-  list_user_workspaces: (_p, c) => executeListUserWorkspaces(c),
-  list_folders: (p, c) => executeListFolders(p as ListFoldersParams, c),
-  create_workflow: (p, c) => executeCreateWorkflow(p as CreateWorkflowParams, c),
-  create_folder: (p, c) => executeCreateFolder(p as CreateFolderParams, c),
-  rename_workflow: (p, c) => executeRenameWorkflow(p as unknown as RenameWorkflowParams, c),
-  update_workflow: (p, c) => executeUpdateWorkflow(p as unknown as UpdateWorkflowParams, c),
-  delete_workflow: (p, c) => executeDeleteWorkflow(p as unknown as DeleteWorkflowParams, c),
-  move_workflow: (p, c) => executeMoveWorkflow(p as unknown as MoveWorkflowParams, c),
-  move_folder: (p, c) => executeMoveFolder(p as unknown as MoveFolderParams, c),
-  rename_folder: (p, c) => executeRenameFolder(p as unknown as RenameFolderParams, c),
-  delete_folder: (p, c) => executeDeleteFolder(p as unknown as DeleteFolderParams, c),
-  get_workflow_data: (p, c) => executeGetWorkflowData(p as GetWorkflowDataParams, c),
-  get_block_outputs: (p, c) => executeGetBlockOutputs(p as GetBlockOutputsParams, c),
-  get_block_upstream_references: (p, c) =>
-    executeGetBlockUpstreamReferences(p as unknown as GetBlockUpstreamReferencesParams, c),
-  run_workflow: (p, c) => executeRunWorkflow(p as RunWorkflowParams, c),
-  run_workflow_until_block: (p, c) =>
-    executeRunWorkflowUntilBlock(p as unknown as RunWorkflowUntilBlockParams, c),
-  run_from_block: (p, c) => executeRunFromBlock(p as unknown as RunFromBlockParams, c),
-  run_block: (p, c) => executeRunBlock(p as unknown as RunBlockParams, c),
-  get_deployed_workflow_state: (p, c) =>
-    executeGetDeployedWorkflowState(p as GetDeployedWorkflowStateParams, c),
-  generate_api_key: (p, c) => executeGenerateApiKey(p as unknown as GenerateApiKeyParams, c),
-  get_platform_actions: () =>
-    Promise.resolve({
-      success: true,
-      output: { content: PLATFORM_ACTIONS_CONTENT },
-    }),
-  set_global_workflow_variables: (p, c) =>
-    executeSetGlobalWorkflowVariables(p as SetGlobalWorkflowVariablesParams, c),
-  deploy_api: (p, c) => executeDeployApi(p as DeployApiParams, c),
-  deploy_chat: (p, c) => executeDeployChat(p as DeployChatParams, c),
-  deploy_mcp: (p, c) => executeDeployMcp(p as DeployMcpParams, c),
-  redeploy: (p, c) => executeRedeploy(p as { workflowId?: string }, c),
-  check_deployment_status: (p, c) =>
-    executeCheckDeploymentStatus(p as CheckDeploymentStatusParams, c),
-  list_workspace_mcp_servers: (p, c) =>
-    executeListWorkspaceMcpServers(p as ListWorkspaceMcpServersParams, c),
-  create_workspace_mcp_server: (p, c) =>
-    executeCreateWorkspaceMcpServer(p as CreateWorkspaceMcpServerParams, c),
-  update_workspace_mcp_server: (p, c) =>
-    executeUpdateWorkspaceMcpServer(p as unknown as UpdateWorkspaceMcpServerParams, c),
-  delete_workspace_mcp_server: (p, c) =>
-    executeDeleteWorkspaceMcpServer(p as unknown as DeleteWorkspaceMcpServerParams, c),
-  get_deployment_version: (p, c) =>
-    executeGetDeploymentVersion(p as { workflowId?: string; version?: number }, c),
-  revert_to_version: (p, c) =>
-    executeRevertToVersion(p as { workflowId?: string; version?: number }, c),
-  manage_credential: async (p, c) => {
-    const params = p as { operation: string; credentialId: string; displayName?: string }
-    const { operation, credentialId, displayName } = params
-    if (!credentialId) {
-      return { success: false, error: 'credentialId is required' }
-    }
-    try {
-      const [row] = await db
-        .select({ id: credential.id, type: credential.type, displayName: credential.displayName })
-        .from(credential)
-        .where(eq(credential.id, credentialId))
-        .limit(1)
-      if (!row) {
-        return { success: false, error: 'Credential not found' }
-      }
-      if (row.type !== 'oauth') {
-        return {
-          success: false,
-          error:
-            'Only OAuth credentials can be managed with this tool. Use set_environment_variables for env vars.',
-        }
-      }
-      switch (operation) {
-        case 'rename': {
-          if (!displayName) {
-            return { success: false, error: 'displayName is required for rename' }
-          }
-          await db
-            .update(credential)
-            .set({ displayName, updatedAt: new Date() })
-            .where(eq(credential.id, credentialId))
-          recordAudit({
-            actorId: c.userId,
-            action: AuditAction.CREDENTIAL_RENAMED,
-            resourceType: AuditResourceType.OAUTH,
-            resourceId: credentialId,
-            description: `Renamed credential to "${displayName}"`,
-          })
-          return { success: true, output: { credentialId, displayName } }
-        }
-        case 'delete': {
-          await db.delete(credential).where(eq(credential.id, credentialId))
-          recordAudit({
-            actorId: c.userId,
-            action: AuditAction.CREDENTIAL_DELETED,
-            resourceType: AuditResourceType.OAUTH,
-            resourceId: credentialId,
-            description: `Deleted credential`,
-          })
-          return { success: true, output: { credentialId, deleted: true } }
-        }
-        default:
-          return {
-            success: false,
-            error: `Unknown operation: ${operation}. Use "rename" or "delete".`,
-          }
-      }
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) }
-    }
-  },
-  create_job: (p, c) => executeCreateJob(p, c),
-  manage_job: (p, c) => executeManageJob(p, c),
-  complete_job: (p, c) => executeCompleteJob(p, c),
-  update_job_history: (p, c) => executeUpdateJobHistory(p, c),
-  oauth_get_auth_link: async (p, c) => {
-    const providerName = (p.providerName || p.provider_name || 'the provider') as string
-    const baseUrl = getBaseUrl()
-
-    try {
-      const result = await generateOAuthLink(
-        c.userId,
-        c.workspaceId,
-        c.workflowId,
-        c.chatId,
-        providerName,
-        baseUrl
-      )
-      return {
-        success: true,
-        output: {
-          message: `Authorization URL generated for ${result.serviceName}. The user must open this URL in a browser to authorize.`,
-          oauth_url: result.url,
-          instructions: `Open this URL in your browser to connect ${result.serviceName}: ${result.url}`,
-          provider: result.serviceName,
-          providerId: result.providerId,
-        },
-      }
-    } catch (err) {
-      logger
-        .withMetadata({ messageId: c.messageId })
-        .warn('Failed to generate OAuth link, falling back to generic URL', {
-          providerName,
-          error: err instanceof Error ? err.message : String(err),
-        })
-      const workspaceUrl = c.workspaceId
-        ? `${baseUrl}/workspace/${c.workspaceId}`
-        : `${baseUrl}/workspace`
-      return {
-        success: false,
-        output: {
-          message: `Could not generate a direct OAuth link for ${providerName}. The user can connect manually from the workspace.`,
-          oauth_url: workspaceUrl,
-          instructions: `Open ${workspaceUrl} in a browser, go to Settings → Credentials, and connect ${providerName} from there.`,
-          provider: providerName,
-          error: err instanceof Error ? err.message : String(err),
-        },
-      }
-    }
-  },
-  oauth_request_access: async (p, _c) => {
-    const providerName = (p.providerName || p.provider_name || 'the provider') as string
-    return {
-      success: true,
-      output: {
-        success: true,
-        status: 'requested',
-        providerName,
-        message: `Requested ${providerName} OAuth connection. The user should complete the OAuth modal in the UI, then retry credential-dependent actions.`,
-      },
-    }
-  },
-  materialize_file: (p, c) => executeMaterializeFile(p, c),
-  manage_custom_tool: (p, c) => executeManageCustomTool(p, c),
-  manage_mcp_tool: (p, c) => executeManageMcpTool(p, c),
-  manage_skill: (p, c) => executeManageSkill(p, c),
-  // VFS tools
-  grep: (p, c) => executeVfsGrep(p, c),
-  glob: (p, c) => executeVfsGlob(p, c),
-  read: (p, c) => executeVfsRead(p, c),
-  list: (p, c) => executeVfsList(p, c),
-
-  // Resource visibility
-  open_resource: async (p: OpenResourceParams, c: ExecutionContext) => {
-    const validated = validateOpenResourceParams(p)
-    if (!validated.success) {
-      return { success: false, error: validated.error }
-    }
-
-    const params = validated.params
-    const resourceType = params.type
-    let resourceId = params.id
-    let title: string = resourceType
-
-    if (resourceType === 'file') {
-      if (!c.workspaceId) {
-        return {
-          success: false,
-          error:
-            'Opening a workspace file requires workspace context. Pass the canonical file UUID from files/by-id/<fileId>/meta.json.',
-        }
-      }
-      if (!isUuid(params.id)) {
-        return {
-          success: false,
-          error:
-            'open_resource for files requires the canonical file UUID. Read files/by-id/<fileId>/meta.json or files/<name>/meta.json and pass the "id" field. Do not pass VFS paths or display names.',
-        }
-      }
-      const record = await getWorkspaceFile(c.workspaceId, params.id)
-      if (!record) {
-        return {
-          success: false,
-          error: `No workspace file with id "${params.id}". Confirm the UUID from files/by-id/<fileId>/meta.json.`,
-        }
-      }
-      resourceId = record.id
-      title = record.name
-    }
-
-    if (resourceType === 'workflow') {
-      const workflow = await getWorkflowById(params.id)
-      if (!workflow) {
-        return {
-          success: false,
-          error: `No workflow with id "${params.id}". Confirm the workflow ID before opening it.`,
-        }
-      }
-      if (c.workspaceId && workflow.workspaceId !== c.workspaceId) {
-        return {
-          success: false,
-          error: `Workflow "${params.id}" was not found in the current workspace.`,
-        }
-      }
-      resourceId = workflow.id
-      title = workflow.name
-    }
-
-    if (resourceType === 'table') {
-      const table = await getTableById(params.id)
-      if (!table) {
-        return {
-          success: false,
-          error: `No table with id "${params.id}". Confirm the table ID before opening it.`,
-        }
-      }
-      if (c.workspaceId && table.workspaceId !== c.workspaceId) {
-        return {
-          success: false,
-          error: `Table "${params.id}" was not found in the current workspace.`,
-        }
-      }
-      resourceId = table.id
-      title = table.name
-    }
-
-    if (resourceType === 'knowledgebase') {
-      const knowledgeBase = await getKnowledgeBaseById(params.id)
-      if (!knowledgeBase) {
-        return {
-          success: false,
-          error: `No knowledge base with id "${params.id}". Confirm the knowledge base ID before opening it.`,
-        }
-      }
-      if (c.workspaceId && knowledgeBase.workspaceId !== c.workspaceId) {
-        return {
-          success: false,
-          error: `Knowledge base "${params.id}" was not found in the current workspace.`,
-        }
-      }
-      resourceId = knowledgeBase.id
-      title = knowledgeBase.name
-    }
-
-    return {
-      success: true,
-      output: { message: `Opened ${resourceType} ${resourceId} for the user` },
-      resources: [
-        {
-          type: resourceType as 'workflow' | 'table' | 'knowledgebase' | 'file',
-          id: resourceId,
-          title,
-        },
-      ],
-    }
-  },
-}
-
-/**
- * Check whether a tool can be executed on the Sim (TypeScript) side.
- *
- * Tools that are only available server-side (e.g. search_patterns)
- * will return false.  The subagent tool_call
- * handler uses this to decide whether to execute a tool locally or let the
- * server's own tool_result SSE event handle it.
- */
-export function isToolAvailableOnSimSide(toolName: string): boolean {
-  if (SERVER_TOOLS.has(toolName)) return true
-  if (toolName in SIM_WORKFLOW_TOOL_HANDLERS) return true
-  if (isMcpTool(toolName)) return true
-  const resolvedToolName = resolveToolId(toolName)
-  return !!getTool(resolvedToolName)
-}
-
-/**
- * Execute a tool server-side without calling internal routes.
- */
-export async function executeToolServerSide(
-  toolCall: ToolCallState,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const toolName = toolCall.name
-  const resolvedToolName = resolveToolId(toolName)
-
-  if (SERVER_TOOLS.has(toolName)) {
-    return executeServerToolDirect(toolName, toolCall.params || {}, context)
-  }
-
-  if (toolName in SIM_WORKFLOW_TOOL_HANDLERS) {
-    return executeSimWorkflowTool(toolName, toolCall.params || {}, context)
-  }
-
-  if (isMcpTool(toolName)) {
-    return executeMcpToolDirect(toolCall, context)
-  }
-
-  const toolConfig = getTool(resolvedToolName)
-  if (!toolConfig) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Tool not found in registry', { toolName, resolvedToolName })
-    return {
-      success: false,
-      error: `Tool not found: ${toolName}`,
-    }
-  }
-
-  return executeIntegrationToolDirect(toolCall, toolConfig, context)
-}
-
-/**
- * Execute an MCP tool via the existing executeTool dispatcher which
- * already handles the mcp- prefix and routes to /api/mcp/tools/execute.
- */
-async function executeMcpToolDirect(
-  toolCall: ToolCallState,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const { userId, workflowId } = context
-
-  let workspaceId = context.workspaceId
-  if (!workspaceId && workflowId) {
-    const wf = await getWorkflowById(workflowId)
-    workspaceId = wf?.workspaceId ?? undefined
-  }
-
-  const params: Record<string, unknown> = {
-    ...(toolCall.params || {}),
-    _context: { workflowId, userId, workspaceId },
-  }
-
-  const result = await executeTool(toolCall.name, params)
-
-  return {
-    success: result.success,
-    output: result.output,
-    error: result.error,
-  }
-}
-
-/**
- * Execute a server tool directly via the server tool router.
- */
-async function executeServerToolDirect(
-  toolName: string,
-  params: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const enrichedParams = { ...params }
-    if (!enrichedParams.workflowId && context.workflowId) {
-      enrichedParams.workflowId = context.workflowId
-    }
-    if (!enrichedParams.workspaceId && context.workspaceId) {
-      enrichedParams.workspaceId = context.workspaceId
-    }
-
-    const result = await routeExecution(toolName, enrichedParams, {
-      userId: context.userId,
-      workspaceId: context.workspaceId,
-      userPermission: context.userPermission,
-      chatId: context.chatId,
-      messageId: context.messageId,
-      abortSignal: context.abortSignal,
-      userStopSignal: context.userStopSignal,
-    })
-
-    const resultRecord =
-      result && typeof result === 'object' && !Array.isArray(result)
-        ? (result as Record<string, unknown>)
-        : null
-
-    // Some server tools return an explicit { success, message, ... } envelope.
-    // Preserve tool-level failures instead of reporting them as transport success.
-    if (resultRecord?.success === false) {
-      const message =
-        (typeof resultRecord.error === 'string' && resultRecord.error) ||
-        (typeof resultRecord.message === 'string' && resultRecord.message) ||
-        `${toolName} failed`
-
-      return {
-        success: false,
-        error: message,
-        output: result,
-      }
-    }
-
-    return { success: true, output: result }
-  } catch (error) {
-    logger.withMetadata({ messageId: context.messageId }).error('Server tool execution failed', {
-      toolName,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Server tool execution failed',
-    }
-  }
-}
-
-async function executeSimWorkflowTool(
-  toolName: string,
-  params: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const handler = SIM_WORKFLOW_TOOL_HANDLERS[toolName]
-  if (!handler) return { success: false, error: `Unsupported workflow tool: ${toolName}` }
-
-  if (context.workflowId) {
-    if (toolName === 'create_workflow') {
-      return {
-        success: false,
-        error:
-          'Cannot create new workflows from the workflow copilot. You are scoped to the current workflow. Use the workspace chat to create new workflows.',
-      }
-    }
-
-    if (
-      toolName === 'edit_workflow' &&
-      params.workflowId &&
-      params.workflowId !== context.workflowId
-    ) {
-      return {
-        success: false,
-        error: `Cannot edit a different workflow. You are scoped to workflow ${context.workflowId}.`,
-      }
-    }
-  }
-
-  return handler(params, context)
-}
-
-/** Timeout for the mark-complete POST to the copilot backend (30 s). */
-const MARK_COMPLETE_TIMEOUT_MS = 30_000
-
-/**
- * Notify the copilot backend that a tool has completed.
- */
-export async function markToolComplete(
-  toolCallId: string,
-  toolName: string,
-  status: number,
-  message?: unknown,
-  data?: unknown,
-  messageId?: string
-): Promise<boolean> {
-  try {
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), MARK_COMPLETE_TIMEOUT_MS)
-
-    try {
-      const response = await fetch(`${SIM_AGENT_API_URL}/api/tools/mark-complete`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
-        },
-        body: JSON.stringify({
-          id: toolCallId,
-          name: toolName,
-          status,
-          message,
-          data,
-        }),
-        signal: controller.signal,
-      })
-
-      if (!response.ok) {
-        logger.withMetadata({ messageId }).warn('Mark-complete call failed', {
-          toolCallId,
-          toolName,
-          status: response.status,
-        })
-        return false
-      }
-
-      return true
-    } finally {
-      clearTimeout(timeoutId)
-    }
-  } catch (error) {
-    const isTimeout = error instanceof DOMException && error.name === 'AbortError'
-    logger.withMetadata({ messageId }).error('Mark-complete call failed', {
-      toolCallId,
-      toolName,
-      timedOut: isTimeout,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return false
-  }
-}
-
-/**
- * Prepare execution context with cached environment values.
- */
-export async function prepareExecutionContext(
-  userId: string,
-  workflowId: string,
-  chatId?: string
-): Promise<ExecutionContext> {
-  const wf = await getWorkflowById(workflowId)
-  const workspaceId = wf?.workspaceId ?? undefined
-
-  const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
-
-  return {
-    userId,
-    workflowId,
-    workspaceId,
-    chatId,
-    decryptedEnvVars,
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/integration-tools.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/integration-tools.ts
deleted file mode 100644
index 7e7d74f4d29..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/integration-tools.ts
+++ /dev/null
@@ -1,285 +0,0 @@
-import { db } from '@sim/db'
-import { account } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import type {
-  ExecutionContext,
-  ToolCallResult,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { isHosted } from '@/lib/core/config/feature-flags'
-import { generateRequestId } from '@/lib/core/utils/request'
-import { getCredentialActorContext } from '@/lib/credentials/access'
-import { getAccessibleOAuthCredentials } from '@/lib/credentials/environment'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { getServiceAccountProviderForProviderId } from '@/lib/oauth/utils'
-import { getTableById, queryRows } from '@/lib/table/service'
-import {
-  downloadWorkspaceFile,
-  findWorkspaceFileRecord,
-  getSandboxWorkspaceFilePath,
-  listWorkspaceFiles,
-} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-import { getWorkflowById } from '@/lib/workflows/utils'
-import { refreshTokenIfNeeded } from '@/app/api/auth/oauth/utils'
-import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
-import { executeTool } from '@/tools'
-import type { ToolConfig } from '@/tools/types'
-import { resolveToolId } from '@/tools/utils'
-
-const logger = createLogger('CopilotIntegrationTools')
-
-function csvEscapeValue(value: unknown): string {
-  if (value === null || value === undefined) return ''
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
-  const str = String(value)
-  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
-    return `"${str.replace(/"/g, '""')}"`
-  }
-  return str
-}
-
-export async function executeIntegrationToolDirect(
-  toolCall: ToolCallState,
-  toolConfig: ToolConfig,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const { userId, workflowId } = context
-  const toolName = resolveToolId(toolCall.name)
-  const toolArgs = toolCall.params || {}
-
-  let workspaceId = context.workspaceId
-  if (!workspaceId && workflowId) {
-    const wf = await getWorkflowById(workflowId)
-    workspaceId = wf?.workspaceId ?? undefined
-  }
-
-  const decryptedEnvVars =
-    context.decryptedEnvVars || (await getEffectiveDecryptedEnv(userId, workspaceId))
-
-  const executionParams = resolveEnvVarReferences(toolArgs, decryptedEnvVars, {
-    deep: true,
-  }) as Record<string, unknown>
-
-  // If the LLM passed a credential/oauthCredential ID directly, verify the user
-  // has active credential_member access before proceeding. This prevents
-  // unauthorized credential usage even if the agent hallucinated or received
-  // a credential ID the user doesn't have access to.
-  const suppliedCredentialId = (executionParams.credentialId ||
-    executionParams.oauthCredential ||
-    executionParams.credential) as string | undefined
-  if (suppliedCredentialId) {
-    const actorCtx = await getCredentialActorContext(suppliedCredentialId, userId)
-    if (!actorCtx.member) {
-      logger.warn('Blocked credential use: user lacks credential_member access', {
-        credentialId: suppliedCredentialId,
-        userId,
-        toolName,
-      })
-      return {
-        success: false,
-        error: `You do not have access to credential "${suppliedCredentialId}". Ask the credential admin to add you as a member, or connect your own account.`,
-      }
-    }
-  }
-
-  if (toolConfig.oauth?.required && toolConfig.oauth.provider) {
-    const provider = toolConfig.oauth.provider
-
-    // Determine which credential to use: supplied by the LLM or auto-resolved
-    let resolvedCredentialId = suppliedCredentialId
-
-    if (!resolvedCredentialId) {
-      if (!workspaceId) {
-        return {
-          success: false,
-          error: `Cannot resolve ${provider} credential without a workspace context.`,
-        }
-      }
-
-      const accessibleCreds = await getAccessibleOAuthCredentials(workspaceId, userId)
-      const saProviderId = getServiceAccountProviderForProviderId(provider)
-      const match =
-        accessibleCreds.find((c) => c.providerId === provider) ||
-        (saProviderId ? accessibleCreds.find((c) => c.providerId === saProviderId) : undefined)
-
-      if (!match) {
-        return {
-          success: false,
-          error: `No accessible ${provider} account found. You either don't have a ${provider} account connected in this workspace, or you don't have access to the existing one. Please connect your own account.`,
-        }
-      }
-
-      resolvedCredentialId = match.id
-    }
-
-    const matchCtx = await getCredentialActorContext(resolvedCredentialId, userId)
-
-    if (matchCtx.credential?.type === 'service_account') {
-      executionParams.oauthCredential = resolvedCredentialId
-    } else {
-      const accountId = matchCtx.credential?.accountId
-      if (!accountId) {
-        return {
-          success: false,
-          error: `OAuth account for ${provider} not found. Please reconnect your account.`,
-        }
-      }
-
-      const [acc] = await db.select().from(account).where(eq(account.id, accountId)).limit(1)
-
-      if (!acc) {
-        return {
-          success: false,
-          error: `OAuth account for ${provider} not found. Please reconnect your account.`,
-        }
-      }
-
-      const requestId = generateRequestId()
-      const { accessToken } = await refreshTokenIfNeeded(requestId, acc, acc.id)
-
-      if (!accessToken) {
-        return {
-          success: false,
-          error: `OAuth token not available for ${provider}. Please reconnect your account.`,
-        }
-      }
-
-      executionParams.accessToken = accessToken
-    }
-  }
-
-  const hasHostedKeySupport = isHosted && !!toolConfig.hosting
-  if (toolConfig.params?.apiKey?.required && !executionParams.apiKey && !hasHostedKeySupport) {
-    return {
-      success: false,
-      error: `API key not provided for ${toolName}. Use {{YOUR_API_KEY_ENV_VAR}} to reference your environment variable.`,
-    }
-  }
-
-  executionParams._context = {
-    workflowId,
-    workspaceId,
-    userId,
-    enforceCredentialAccess: true,
-  }
-
-  if (toolName === 'function_execute') {
-    executionParams.envVars = decryptedEnvVars
-    executionParams.workflowVariables = {}
-    executionParams.blockData = {}
-    executionParams.blockNameMapping = {}
-    executionParams.language = executionParams.language || 'javascript'
-    executionParams.timeout = executionParams.timeout || 30000
-
-    if (isHosted && workspaceId) {
-      const sandboxFiles: Array<{ path: string; content: string }> = []
-      const MAX_FILE_SIZE = 10 * 1024 * 1024
-      const MAX_TOTAL_SIZE = 50 * 1024 * 1024
-      const TEXT_EXTENSIONS = new Set([
-        'csv',
-        'json',
-        'txt',
-        'md',
-        'html',
-        'xml',
-        'tsv',
-        'yaml',
-        'yml',
-      ])
-      let totalSize = 0
-
-      const inputFileIds = executionParams.inputFiles as string[] | undefined
-      if (inputFileIds?.length) {
-        const allFiles = await listWorkspaceFiles(workspaceId)
-        for (const fileRef of inputFileIds) {
-          const record = findWorkspaceFileRecord(allFiles, fileRef)
-          if (!record) {
-            logger.warn('Sandbox input file not found', { fileRef })
-            continue
-          }
-          const ext = record.name.split('.').pop()?.toLowerCase() ?? ''
-          if (!TEXT_EXTENSIONS.has(ext)) {
-            logger.warn('Skipping non-text sandbox input file', {
-              fileId: record.id,
-              fileName: record.name,
-              ext,
-            })
-            continue
-          }
-          if (record.size > MAX_FILE_SIZE) {
-            logger.warn('Sandbox input file exceeds size limit', {
-              fileId: record.id,
-              fileName: record.name,
-              size: record.size,
-            })
-            continue
-          }
-          if (totalSize + record.size > MAX_TOTAL_SIZE) {
-            logger.warn('Sandbox input total size limit reached, skipping remaining files')
-            break
-          }
-          const buffer = await downloadWorkspaceFile(record)
-          totalSize += buffer.length
-          const textContent = buffer.toString('utf-8')
-          sandboxFiles.push({
-            path: getSandboxWorkspaceFilePath(record),
-            content: textContent,
-          })
-          sandboxFiles.push({
-            path: `/home/user/${record.name}`,
-            content: textContent,
-          })
-        }
-      }
-
-      const inputTableIds = executionParams.inputTables as string[] | undefined
-      if (inputTableIds?.length) {
-        for (const tableId of inputTableIds) {
-          const table = await getTableById(tableId)
-          if (!table) {
-            logger.warn('Sandbox input table not found', { tableId })
-            continue
-          }
-          const { rows } = await queryRows(tableId, workspaceId, { limit: 10000 }, 'sandbox-input')
-          const schema = table.schema as { columns: Array<{ name: string; type?: string }> }
-          const cols = schema.columns.map((c) => c.name)
-          const typeComment = `# types: ${schema.columns.map((c) => `${c.name}=${c.type || 'string'}`).join(', ')}`
-          const csvLines = [typeComment, cols.join(',')]
-          for (const row of rows) {
-            csvLines.push(
-              cols.map((c) => csvEscapeValue((row.data as Record<string, unknown>)[c])).join(',')
-            )
-          }
-          const csvContent = csvLines.join('\n')
-          if (totalSize + csvContent.length > MAX_TOTAL_SIZE) {
-            logger.warn('Sandbox input total size limit reached, skipping remaining tables')
-            break
-          }
-          totalSize += csvContent.length
-          sandboxFiles.push({ path: `/home/user/tables/${tableId}.csv`, content: csvContent })
-        }
-      }
-
-      if (sandboxFiles.length > 0) {
-        executionParams._sandboxFiles = sandboxFiles
-        logger.info('Prepared sandbox input files', {
-          fileCount: sandboxFiles.length,
-          totalSize,
-          paths: sandboxFiles.map((f) => f.path),
-        })
-      }
-
-      executionParams.inputFiles = undefined
-      executionParams.inputTables = undefined
-    }
-  }
-
-  const result = await executeTool(toolName, executionParams)
-
-  return {
-    success: result.success,
-    output: result.output,
-    error: result.error,
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/index.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/index.ts
deleted file mode 100644
index b908b07108d..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './mutations'
-export * from './queries'
diff --git a/apps/sim/lib/copilot/orchestrator/persistence.ts b/apps/sim/lib/copilot/persistence/tool-confirm/index.ts
similarity index 65%
rename from apps/sim/lib/copilot/orchestrator/persistence.ts
rename to apps/sim/lib/copilot/persistence/tool-confirm/index.ts
index d0b47ecb8fc..0b18af68bee 100644
--- a/apps/sim/lib/copilot/orchestrator/persistence.ts
+++ b/apps/sim/lib/copilot/persistence/tool-confirm/index.ts
@@ -1,9 +1,13 @@
 import { createLogger } from '@sim/logger'
-import type { AsyncCompletionEnvelope } from '@/lib/copilot/async-runs/lifecycle'
+import { ASYNC_TOOL_STATUS, type AsyncCompletionEnvelope } from '@/lib/copilot/async-runs/lifecycle'
 import { getAsyncToolCalls } from '@/lib/copilot/async-runs/repository'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import { getRedisClient } from '@/lib/core/config/redis'
 import { createPubSubChannel } from '@/lib/events/pubsub'
 
 const logger = createLogger('CopilotOrchestratorPersistence')
+const TOOL_CONFIRMATION_TTL_SECONDS = 60 * 10
+const toolConfirmationKey = (toolCallId: string) => `copilot:tool-confirmation:${toolCallId}`
 
 const toolConfirmationChannel = createPubSubChannel<AsyncCompletionEnvelope>({
   channel: 'copilot:tool-confirmation',
@@ -19,16 +23,22 @@ export async function getToolConfirmation(toolCallId: string): Promise<{
   timestamp?: string
   data?: Record<string, unknown>
 } | null> {
-  const [row] = await getAsyncToolCalls([toolCallId]).catch(() => [])
+  const [row] = await getAsyncToolCalls([toolCallId]).catch((err) => {
+    logger.warn('Failed to fetch async tool calls', {
+      toolCallId,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return []
+  })
   if (!row) return null
   return {
     status:
-      row.status === 'completed'
-        ? 'success'
-        : row.status === 'failed'
-          ? 'error'
-          : row.status === 'cancelled'
-            ? 'cancelled'
+      row.status === ASYNC_TOOL_STATUS.completed
+        ? MothershipStreamV1ToolOutcome.success
+        : row.status === ASYNC_TOOL_STATUS.failed
+          ? MothershipStreamV1ToolOutcome.error
+          : row.status === ASYNC_TOOL_STATUS.cancelled
+            ? MothershipStreamV1ToolOutcome.cancelled
             : row.status,
     message: row.error || undefined,
     data: (row.result as Record<string, unknown> | null) || undefined,
@@ -41,6 +51,34 @@ export function publishToolConfirmation(event: AsyncCompletionEnvelope): void {
     toolCallId: event.toolCallId,
     status: event.status,
   })
+  const redis = getRedisClient()
+  if (redis) {
+    void redis
+      .set(
+        toolConfirmationKey(event.toolCallId),
+        JSON.stringify(event),
+        'EX',
+        TOOL_CONFIRMATION_TTL_SECONDS
+      )
+      .then(() => {
+        logger.info('Persisted tool confirmation in Redis', {
+          toolCallId: event.toolCallId,
+          status: event.status,
+          redisKey: toolConfirmationKey(event.toolCallId),
+        })
+      })
+      .catch((error) => {
+        logger.warn('Failed to persist tool confirmation in Redis', {
+          toolCallId: event.toolCallId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      })
+  } else {
+    logger.warn('Redis unavailable while publishing tool confirmation', {
+      toolCallId: event.toolCallId,
+      status: event.status,
+    })
+  }
   toolConfirmationChannel.publish(event)
 }
 
diff --git a/apps/sim/lib/copilot/orchestrator/persistence.test.ts b/apps/sim/lib/copilot/persistence/tool-confirm/tool-confirm.test.ts
similarity index 98%
rename from apps/sim/lib/copilot/orchestrator/persistence.test.ts
rename to apps/sim/lib/copilot/persistence/tool-confirm/tool-confirm.test.ts
index 0474fab9f80..8c8c4e9f253 100644
--- a/apps/sim/lib/copilot/orchestrator/persistence.test.ts
+++ b/apps/sim/lib/copilot/persistence/tool-confirm/tool-confirm.test.ts
@@ -33,7 +33,7 @@ import {
   getToolConfirmation,
   publishToolConfirmation,
   waitForToolConfirmation,
-} from './persistence'
+} from '@/lib/copilot/persistence/tool-confirm'
 
 describe('copilot orchestrator persistence', () => {
   let row: {
diff --git a/apps/sim/lib/copilot/request/context/request-context.ts b/apps/sim/lib/copilot/request/context/request-context.ts
new file mode 100644
index 00000000000..0f4fe41b1db
--- /dev/null
+++ b/apps/sim/lib/copilot/request/context/request-context.ts
@@ -0,0 +1,30 @@
+import { TraceCollector } from '@/lib/copilot/request/trace'
+import type { StreamingContext } from '@/lib/copilot/request/types'
+
+/**
+ * Create a fresh StreamingContext.
+ */
+export function createStreamingContext(overrides?: Partial<StreamingContext>): StreamingContext {
+  return {
+    chatId: undefined,
+    executionId: undefined,
+    runId: undefined,
+    messageId: crypto.randomUUID(),
+    accumulatedContent: '',
+    contentBlocks: [],
+    toolCalls: new Map(),
+    pendingToolPromises: new Map(),
+    currentThinkingBlock: null,
+    isInThinkingBlock: false,
+    subAgentParentToolCallId: undefined,
+    subAgentParentStack: [],
+    subAgentContent: {},
+    subAgentToolCalls: {},
+    pendingContent: '',
+    streamComplete: false,
+    wasAborted: false,
+    errors: [],
+    trace: new TraceCollector(),
+    ...overrides,
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/stream/core.test.ts b/apps/sim/lib/copilot/request/context/result.test.ts
similarity index 81%
rename from apps/sim/lib/copilot/orchestrator/stream/core.test.ts
rename to apps/sim/lib/copilot/request/context/result.test.ts
index 97e614caf6b..0e8f8cd97ca 100644
--- a/apps/sim/lib/copilot/orchestrator/stream/core.test.ts
+++ b/apps/sim/lib/copilot/request/context/result.test.ts
@@ -2,8 +2,10 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { buildToolCallSummaries } from '@/lib/copilot/orchestrator/stream/core'
-import type { StreamingContext } from '@/lib/copilot/orchestrator/types'
+import { FunctionExecute } from '@/lib/copilot/generated/tool-catalog-v1'
+import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
+import { TraceCollector } from '@/lib/copilot/request/trace'
+import type { StreamingContext } from '@/lib/copilot/request/types'
 
 function makeContext(): StreamingContext {
   return {
@@ -27,6 +29,7 @@ function makeContext(): StreamingContext {
     streamComplete: false,
     wasAborted: false,
     errors: [],
+    trace: new TraceCollector(),
   }
 }
 
@@ -50,7 +53,7 @@ describe('buildToolCallSummaries', () => {
     const context = makeContext()
     context.toolCalls.set('tool-2', {
       id: 'tool-2',
-      name: 'function_execute',
+      name: FunctionExecute.id,
       status: 'executing',
       startTime: 1,
     })
diff --git a/apps/sim/lib/copilot/request/context/result.ts b/apps/sim/lib/copilot/request/context/result.ts
new file mode 100644
index 00000000000..8884ac4b23f
--- /dev/null
+++ b/apps/sim/lib/copilot/request/context/result.ts
@@ -0,0 +1,29 @@
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamingContext, ToolCallSummary } from '@/lib/copilot/request/types'
+
+/**
+ * Build a ToolCallSummary array from the streaming context.
+ */
+export function buildToolCallSummaries(context: StreamingContext): ToolCallSummary[] {
+  return Array.from(context.toolCalls.values()).map((toolCall) => {
+    let status = toolCall.status
+    if (toolCall.result && toolCall.result.success !== undefined) {
+      status = toolCall.result.success
+        ? MothershipStreamV1ToolOutcome.success
+        : MothershipStreamV1ToolOutcome.error
+    } else if ((status === 'pending' || status === 'executing') && toolCall.error) {
+      status = MothershipStreamV1ToolOutcome.error
+    }
+
+    return {
+      id: toolCall.id,
+      name: toolCall.name,
+      status,
+      params: toolCall.params,
+      result: toolCall.result?.output,
+      error: toolCall.error,
+      durationMs:
+        toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
+    }
+  })
+}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/parser.ts b/apps/sim/lib/copilot/request/go/parser.ts
similarity index 77%
rename from apps/sim/lib/copilot/orchestrator/sse/parser.ts
rename to apps/sim/lib/copilot/request/go/parser.ts
index d2fd0355c85..1b3b06bc78a 100644
--- a/apps/sim/lib/copilot/orchestrator/sse/parser.ts
+++ b/apps/sim/lib/copilot/request/go/parser.ts
@@ -1,16 +1,18 @@
 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.
+ * Processes an SSE stream by calling onEvent for each parsed event.
+ *
+ * @param onEvent Called per parsed event. Return true to stop processing.
  */
-export async function* parseSSEStream(
+export async function processSSEStream(
   reader: ReadableStreamDefaultReader<Uint8Array>,
   decoder: TextDecoder,
-  abortSignal?: AbortSignal
-): AsyncGenerator<SSEEvent> {
+  abortSignal: AbortSignal | undefined,
+  onEvent: (event: unknown) => boolean | undefined | Promise<boolean | undefined>
+): Promise<void> {
   let buffer = ''
 
   try {
@@ -28,6 +30,7 @@ export async function* parseSSEStream(
         const lines = buffer.split('\n')
         buffer = lines.pop() || ''
 
+        let stopped = false
         for (const line of lines) {
           if (abortSignal?.aborted) {
             logger.info('SSE stream aborted mid-chunk (between events)')
@@ -40,9 +43,9 @@ export async function* parseSSEStream(
           if (jsonStr === '[DONE]') continue
 
           try {
-            const event = JSON.parse(jsonStr) as SSEEvent
-            if (event?.type) {
-              yield event
+            if (await onEvent(JSON.parse(jsonStr))) {
+              stopped = true
+              break
             }
           } catch (error) {
             logger.warn('Failed to parse SSE event', {
@@ -51,6 +54,7 @@ export async function* parseSSEStream(
             })
           }
         }
+        if (stopped) break
       }
     } catch (error) {
       const aborted =
@@ -64,10 +68,7 @@ export async function* parseSSEStream(
 
     if (buffer.trim() && buffer.startsWith('data: ')) {
       try {
-        const event = JSON.parse(buffer.slice(6)) as SSEEvent
-        if (event?.type) {
-          yield event
-        }
+        await onEvent(JSON.parse(buffer.slice(6)))
       } catch (error) {
         logger.warn('Failed to parse final SSE buffer', {
           preview: buffer.slice(0, 200),
diff --git a/apps/sim/lib/copilot/request/go/stream.ts b/apps/sim/lib/copilot/request/go/stream.ts
new file mode 100644
index 00000000000..10fd7b09e4a
--- /dev/null
+++ b/apps/sim/lib/copilot/request/go/stream.ts
@@ -0,0 +1,519 @@
+import { createLogger } from '@sim/logger'
+import { ORCHESTRATION_TIMEOUT_MS } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1SpanPayloadKind,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { processSSEStream } from '@/lib/copilot/request/go/parser'
+import {
+  handleSubagentRouting,
+  sseHandlers,
+  subAgentHandlers,
+} from '@/lib/copilot/request/handlers'
+import { eventToStreamEvent, isEventRecord } from '@/lib/copilot/request/session'
+import { shouldSkipToolCallEvent, shouldSkipToolResultEvent } from '@/lib/copilot/request/sse-utils'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+
+const logger = createLogger('CopilotGoStream')
+
+type FilePreviewServerState = {
+  raw: string
+  started: boolean
+  operation?: string
+  targetKind?: string
+  fileId?: string
+  fileName?: string
+  title?: string
+  editMetaKey?: string
+  targetKey?: string
+  lastContentSnapshot?: string
+}
+
+function extractJsonString(raw: string, key: string): string | undefined {
+  const pattern = new RegExp(`"${key}"\\s*:\\s*"`)
+  const m = pattern.exec(raw)
+  if (!m) return undefined
+  const start = m.index + m[0].length
+  let end = -1
+  for (let i = start; i < raw.length; i++) {
+    if (raw[i] === '\\') {
+      i++
+      continue
+    }
+    if (raw[i] === '"') {
+      end = i
+      break
+    }
+  }
+  if (end === -1) return undefined
+  return raw
+    .slice(start, end)
+    .replace(/\\n/g, '\n')
+    .replace(/\\t/g, '\t')
+    .replace(/\\r/g, '\r')
+    .replace(/\\"/g, '"')
+    .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+    .replace(/\\\\/g, '\\')
+}
+
+function extractJsonBoolean(raw: string, key: string): boolean | undefined {
+  const match = raw.match(new RegExp(`"${key}"\\s*:\\s*(true|false)`))
+  if (!match) return undefined
+  return match[1] === 'true'
+}
+
+function extractJsonNumber(raw: string, key: string): number | undefined {
+  const match = raw.match(new RegExp(`"${key}"\\s*:\\s*(\\d+)`))
+  if (!match) return undefined
+  return Number.parseInt(match[1], 10)
+}
+
+function decodeJsonStringPrefix(input: string): string {
+  let output = ''
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i]
+    if (ch !== '\\') {
+      output += ch
+      continue
+    }
+    const next = input[i + 1]
+    if (!next) break
+    if (next === 'n') {
+      output += '\n'
+      i++
+      continue
+    }
+    if (next === 't') {
+      output += '\t'
+      i++
+      continue
+    }
+    if (next === 'r') {
+      output += '\r'
+      i++
+      continue
+    }
+    if (next === '"') {
+      output += '"'
+      i++
+      continue
+    }
+    if (next === '\\') {
+      output += '\\'
+      i++
+      continue
+    }
+    if (next === '/') {
+      output += '/'
+      i++
+      continue
+    }
+    if (next === 'b') {
+      output += '\b'
+      i++
+      continue
+    }
+    if (next === 'f') {
+      output += '\f'
+      i++
+      continue
+    }
+    if (next === 'u') {
+      const hex = input.slice(i + 2, i + 6)
+      if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/.test(hex)) {
+        break
+      }
+      output += String.fromCharCode(Number.parseInt(hex, 16))
+      i += 5
+      continue
+    }
+    break
+  }
+  return output
+}
+
+function extractStreamedContent(raw: string, preferredKey: 'content' | 'replace'): string {
+  const marker = `"${preferredKey}":`
+  const idx = raw.indexOf(marker)
+  if (idx === -1) return ''
+  const rest = raw.slice(idx + marker.length).trimStart()
+  if (!rest.startsWith('"')) return rest
+  let end = -1
+  for (let i = 1; i < rest.length; i++) {
+    if (rest[i] === '\\') {
+      i++
+      continue
+    }
+    if (rest[i] === '"') {
+      end = i
+      break
+    }
+  }
+  const inner = end === -1 ? rest.slice(1) : rest.slice(1, end)
+  return decodeJsonStringPrefix(inner)
+}
+
+function buildPreviewContent(raw: string, strategy?: string): string {
+  if (strategy === 'search_replace') {
+    return extractStreamedContent(raw, 'replace')
+  }
+  return extractStreamedContent(raw, 'content')
+}
+
+export class CopilotBackendError extends Error {
+  status?: number
+  body?: string
+
+  constructor(message: string, options?: { status?: number; body?: string }) {
+    super(message)
+    this.name = 'CopilotBackendError'
+    this.status = options?.status
+    this.body = options?.body
+  }
+}
+
+export class BillingLimitError extends Error {
+  constructor(public readonly userId: string) {
+    super('Usage limit reached')
+    this.name = 'BillingLimitError'
+  }
+}
+
+/**
+ * Options for the shared stream processing loop.
+ */
+export interface StreamLoopOptions extends OrchestratorOptions {
+  /**
+   * Called for each normalized event BEFORE standard handler dispatch.
+   * Return true to skip the default handler for this event.
+   */
+  onBeforeDispatch?: (event: StreamEvent, context: StreamingContext) => boolean | undefined
+}
+
+// Pre-resolve text handlers at module level to avoid map lookups in the hot path.
+const textHandler = sseHandlers[MothershipStreamV1EventType.text]
+const subagentTextHandler = subAgentHandlers[MothershipStreamV1EventType.text]
+
+/**
+ * Run the SSE stream processing loop against the Go backend.
+ *
+ * Handles: fetch -> parse -> normalize -> dedupe -> subagent routing -> handler dispatch.
+ * Callers provide the fetch URL/options and can intercept events via onBeforeDispatch.
+ *
+ * Optimised hot path: text events (the most frequent) bypass tool-call dedup
+ * checks and are dispatched synchronously without any await, eliminating ~4
+ * microtask yields per text event vs the previous async-generator + await chain.
+ */
+export async function runStreamLoop(
+  fetchUrl: string,
+  fetchOptions: RequestInit,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: StreamLoopOptions
+): Promise<void> {
+  const { timeout = ORCHESTRATION_TIMEOUT_MS, abortSignal } = options
+  const filePreviewState = new Map<string, FilePreviewServerState>()
+
+  const fetchSpan = context.trace.startSpan(
+    `HTTP Request → ${new URL(fetchUrl).pathname}`,
+    'sim.http.fetch',
+    { url: fetchUrl }
+  )
+  const response = await fetch(fetchUrl, {
+    ...fetchOptions,
+    signal: abortSignal,
+  })
+
+  if (!response.ok) {
+    context.trace.endSpan(fetchSpan, 'error')
+    const errorText = await response.text().catch(() => '')
+
+    if (response.status === 402) {
+      throw new BillingLimitError(execContext.userId)
+    }
+
+    throw new CopilotBackendError(
+      `Copilot backend error (${response.status}): ${errorText || response.statusText}`,
+      { status: response.status, body: errorText || response.statusText }
+    )
+  }
+
+  if (!response.body) {
+    context.trace.endSpan(fetchSpan, 'error')
+    throw new CopilotBackendError('Copilot backend response missing body')
+  }
+
+  context.trace.endSpan(fetchSpan)
+  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 {
+    await processSSEStream(reader, decoder, abortSignal, async (raw) => {
+      if (abortSignal?.aborted) {
+        context.wasAborted = true
+        return true
+      }
+
+      if (!isEventRecord(raw)) {
+        logger.warn('Received non-contract stream event on shared path; dropping event')
+        return
+      }
+
+      const streamEvent = eventToStreamEvent(raw)
+      if (raw.trace?.requestId) {
+        context.requestId = raw.trace.requestId
+        context.trace.setGoTraceId(raw.trace.requestId)
+      }
+
+      if (shouldSkipToolCallEvent(streamEvent) || shouldSkipToolResultEvent(streamEvent)) {
+        return
+      }
+
+      if (
+        streamEvent.type === MothershipStreamV1EventType.tool &&
+        streamEvent.payload.phase === 'args_delta' &&
+        streamEvent.payload.toolName === 'workspace_file' &&
+        typeof streamEvent.payload.toolCallId === 'string' &&
+        typeof streamEvent.payload.argumentsDelta === 'string'
+      ) {
+        const toolCallId = streamEvent.payload.toolCallId as string
+        const delta = streamEvent.payload.argumentsDelta as string
+        const state = filePreviewState.get(toolCallId) ?? {
+          raw: '',
+          started: false,
+        }
+        state.raw += delta
+
+        if (!state.started) {
+          state.started = true
+          await options.onEvent?.({
+            type: MothershipStreamV1EventType.tool,
+            payload: {
+              toolCallId,
+              toolName: 'workspace_file',
+              previewPhase: 'file_preview_start',
+            },
+            ...(streamEvent.scope ? { scope: streamEvent.scope } : {}),
+          })
+        }
+
+        const operation = extractJsonString(state.raw, 'operation')
+        const targetKind = extractJsonString(state.raw, 'kind')
+        const fileId = extractJsonString(state.raw, 'fileId')
+        const fileName = extractJsonString(state.raw, 'fileName')
+        const title = extractJsonString(state.raw, 'title')
+        if (operation) state.operation = operation
+        if (targetKind) state.targetKind = targetKind
+        if (fileId) state.fileId = fileId
+        if (fileName) state.fileName = fileName
+        if (title) state.title = title
+
+        const targetKey = JSON.stringify({
+          operation: state.operation,
+          targetKind: state.targetKind,
+          fileId: state.fileId,
+          fileName: state.fileName,
+          title: state.title,
+        })
+        if (
+          state.targetKind &&
+          (state.targetKind === 'new_file' ? !!state.fileName : !!state.fileId) &&
+          state.targetKey !== targetKey
+        ) {
+          state.targetKey = targetKey
+          await options.onEvent?.({
+            type: MothershipStreamV1EventType.tool,
+            payload: {
+              toolCallId,
+              toolName: 'workspace_file',
+              previewPhase: 'file_preview_target',
+              operation: state.operation,
+              target: {
+                kind: state.targetKind,
+                ...(state.fileId ? { fileId: state.fileId } : {}),
+                ...(state.fileName ? { fileName: state.fileName } : {}),
+              },
+              ...(state.title ? { title: state.title } : {}),
+            },
+            ...(streamEvent.scope ? { scope: streamEvent.scope } : {}),
+          })
+        }
+
+        const strategy = extractJsonString(state.raw, 'strategy')
+        const editMetaPayload = strategy
+          ? {
+              strategy,
+              ...(extractJsonString(state.raw, 'mode')
+                ? { mode: extractJsonString(state.raw, 'mode') }
+                : {}),
+              ...(extractJsonNumber(state.raw, 'occurrence') !== undefined
+                ? { occurrence: extractJsonNumber(state.raw, 'occurrence') }
+                : {}),
+              ...(extractJsonString(state.raw, 'search')
+                ? { search: extractJsonString(state.raw, 'search') }
+                : {}),
+              ...(extractJsonBoolean(state.raw, 'replaceAll') !== undefined
+                ? { replaceAll: extractJsonBoolean(state.raw, 'replaceAll') }
+                : {}),
+              ...(extractJsonString(state.raw, 'before_anchor')
+                ? { before_anchor: extractJsonString(state.raw, 'before_anchor') }
+                : {}),
+              ...(extractJsonString(state.raw, 'after_anchor')
+                ? { after_anchor: extractJsonString(state.raw, 'after_anchor') }
+                : {}),
+              ...(extractJsonString(state.raw, 'anchor')
+                ? { anchor: extractJsonString(state.raw, 'anchor') }
+                : {}),
+              ...(extractJsonString(state.raw, 'start_anchor')
+                ? { start_anchor: extractJsonString(state.raw, 'start_anchor') }
+                : {}),
+              ...(extractJsonString(state.raw, 'end_anchor')
+                ? { end_anchor: extractJsonString(state.raw, 'end_anchor') }
+                : {}),
+            }
+          : undefined
+        const editMetaKey = editMetaPayload ? JSON.stringify(editMetaPayload) : undefined
+        if (editMetaPayload && state.editMetaKey !== editMetaKey) {
+          state.editMetaKey = editMetaKey
+          await options.onEvent?.({
+            type: MothershipStreamV1EventType.tool,
+            payload: {
+              toolCallId,
+              toolName: 'workspace_file',
+              previewPhase: 'file_preview_edit_meta',
+              edit: editMetaPayload,
+            },
+            ...(streamEvent.scope ? { scope: streamEvent.scope } : {}),
+          })
+        }
+
+        const streamedContent = buildPreviewContent(state.raw, strategy)
+        if (streamedContent !== (state.lastContentSnapshot ?? '')) {
+          state.lastContentSnapshot = streamedContent
+          await options.onEvent?.({
+            type: MothershipStreamV1EventType.tool,
+            payload: {
+              toolCallId,
+              toolName: 'workspace_file',
+              previewPhase: 'file_preview_content',
+              content: streamedContent,
+            },
+            ...(streamEvent.scope ? { scope: streamEvent.scope } : {}),
+          })
+        }
+
+        filePreviewState.set(toolCallId, state)
+      }
+
+      try {
+        await options.onEvent?.(streamEvent)
+      } catch (error) {
+        logger.warn('Failed to forward stream event', {
+          type: streamEvent.type,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+
+      // Yield a macrotask so Node.js flushes the HTTP response buffer to
+      // the browser. Microtask yields (await Promise.resolve()) are not
+      // enough — the I/O layer needs a full event loop tick to write.
+      await new Promise<void>((resolve) => setImmediate(resolve))
+
+      if (options.onBeforeDispatch?.(streamEvent, context)) {
+        return context.streamComplete || undefined
+      }
+
+      if (
+        streamEvent.type === MothershipStreamV1EventType.span &&
+        streamEvent.payload.kind === MothershipStreamV1SpanPayloadKind.subagent
+      ) {
+        const spanData =
+          streamEvent.payload.data &&
+          typeof streamEvent.payload.data === 'object' &&
+          !Array.isArray(streamEvent.payload.data)
+            ? (streamEvent.payload.data as Record<string, unknown>)
+            : undefined
+        const toolCallId =
+          (streamEvent.payload.parentToolCallId as string | undefined) ||
+          (spanData?.tool_call_id as string | undefined)
+        const subagentName = streamEvent.payload.agent as string | undefined
+        const spanEvt = streamEvent.payload.event as string | undefined
+        const isPendingPause = spanData?.pending === true
+        if (spanEvt === MothershipStreamV1SpanLifecycleEvent.start) {
+          const lastParent = context.subAgentParentStack[context.subAgentParentStack.length - 1]
+          const lastBlock = context.contentBlocks[context.contentBlocks.length - 1]
+          if (toolCallId) {
+            if (lastParent !== toolCallId) {
+              context.subAgentParentStack.push(toolCallId)
+            }
+            context.subAgentParentToolCallId = toolCallId
+            context.subAgentContent[toolCallId] ??= ''
+            context.subAgentToolCalls[toolCallId] ??= []
+          }
+          if (
+            subagentName &&
+            !(
+              lastParent === toolCallId &&
+              lastBlock?.type === 'subagent' &&
+              lastBlock.content === subagentName
+            )
+          ) {
+            context.contentBlocks.push({
+              type: 'subagent',
+              content: subagentName,
+              timestamp: Date.now(),
+            })
+          }
+          return
+        }
+        if (spanEvt === MothershipStreamV1SpanLifecycleEvent.end) {
+          if (isPendingPause) {
+            return
+          }
+          if (context.subAgentParentStack.length > 0) {
+            context.subAgentParentStack.pop()
+          } else {
+            logger.warn('subagent end without matching start')
+          }
+          context.subAgentParentToolCallId =
+            context.subAgentParentStack.length > 0
+              ? context.subAgentParentStack[context.subAgentParentStack.length - 1]
+              : undefined
+          return
+        }
+      }
+
+      if (handleSubagentRouting(streamEvent, context)) {
+        const handler = subAgentHandlers[streamEvent.type]
+        if (handler) {
+          handler(streamEvent, context, execContext, options)
+        }
+        return context.streamComplete || undefined
+      }
+
+      const handler = sseHandlers[streamEvent.type]
+      if (handler) {
+        handler(streamEvent, context, execContext, options)
+      }
+      return context.streamComplete || undefined
+    })
+  } finally {
+    if (abortSignal?.aborted) {
+      context.wasAborted = true
+      await reader.cancel().catch(() => {})
+    }
+    clearTimeout(timeoutId)
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/complete.ts b/apps/sim/lib/copilot/request/handlers/complete.ts
new file mode 100644
index 00000000000..ba7ebda6aa5
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/complete.ts
@@ -0,0 +1,29 @@
+import { asRecord, getEventData } from '@/lib/copilot/request/sse-utils'
+import type { StreamHandler } from './types'
+
+export const handleCompleteEvent: StreamHandler = (event, context) => {
+  const d = getEventData(event)
+  if (!d) {
+    context.streamComplete = true
+    return
+  }
+
+  if (d.usage) {
+    const u = asRecord(d.usage)
+    context.usage = {
+      prompt: (context.usage?.prompt || 0) + ((u.input_tokens as number) || 0),
+      completion: (context.usage?.completion || 0) + ((u.output_tokens as number) || 0),
+    }
+  }
+
+  if (d.cost) {
+    const c = asRecord(d.cost)
+    context.cost = {
+      input: (context.cost?.input || 0) + ((c.input as number) || 0),
+      output: (context.cost?.output || 0) + ((c.output as number) || 0),
+      total: (context.cost?.total || 0) + ((c.total as number) || 0),
+    }
+  }
+
+  context.streamComplete = true
+}
diff --git a/apps/sim/lib/copilot/request/handlers/error.ts b/apps/sim/lib/copilot/request/handlers/error.ts
new file mode 100644
index 00000000000..225534d066f
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/error.ts
@@ -0,0 +1,11 @@
+import { getEventData } from '@/lib/copilot/request/sse-utils'
+import type { StreamHandler } from './types'
+
+export const handleErrorEvent: StreamHandler = (event, context) => {
+  const d = getEventData(event)
+  const message = (d?.message || d?.error) as string | undefined
+  if (message) {
+    context.errors.push(message)
+  }
+  context.streamComplete = true
+}
diff --git a/apps/sim/lib/copilot/request/handlers/handlers.test.ts b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
new file mode 100644
index 00000000000..674e6a64681
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
@@ -0,0 +1,510 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { TraceCollector } from '@/lib/copilot/request/trace'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+const { isSimExecuted, executeTool, ensureHandlersRegistered } = vi.hoisted(() => ({
+  isSimExecuted: vi.fn().mockReturnValue(true),
+  executeTool: vi.fn().mockResolvedValue({ success: true, output: { ok: true } }),
+  ensureHandlersRegistered: vi.fn(),
+}))
+
+const { upsertAsyncToolCall, markAsyncToolRunning, completeAsyncToolCall } = vi.hoisted(() => ({
+  upsertAsyncToolCall: vi.fn(),
+  markAsyncToolRunning: vi.fn(),
+  completeAsyncToolCall: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/tool-executor', () => ({
+  isSimExecuted,
+  executeTool,
+  ensureHandlersRegistered,
+  getToolEntry: vi.fn().mockReturnValue(undefined),
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/copilot/async-runs/repository')>(
+    '@/lib/copilot/async-runs/repository'
+  )
+  return {
+    ...actual,
+    upsertAsyncToolCall,
+    markAsyncToolRunning,
+    completeAsyncToolCall,
+  }
+})
+
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { sseHandlers, subAgentHandlers } from '@/lib/copilot/request/handlers'
+import type { ExecutionContext, StreamEvent, StreamingContext } from '@/lib/copilot/request/types'
+
+describe('sse-handlers tool lifecycle', () => {
+  let context: StreamingContext
+  let execContext: ExecutionContext
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    upsertAsyncToolCall.mockResolvedValue(null)
+    markAsyncToolRunning.mockResolvedValue(null)
+    completeAsyncToolCall.mockResolvedValue(null)
+    context = {
+      chatId: undefined,
+      messageId: 'msg-1',
+      accumulatedContent: '',
+      trace: new TraceCollector(),
+      contentBlocks: [],
+      toolCalls: new Map(),
+      pendingToolPromises: new Map(),
+      currentThinkingBlock: null,
+      isInThinkingBlock: false,
+      subAgentParentToolCallId: undefined,
+      subAgentParentStack: [],
+      subAgentContent: {},
+      subAgentToolCalls: {},
+      pendingContent: '',
+      streamComplete: false,
+      wasAborted: false,
+      errors: [],
+    }
+    execContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+  })
+
+  it('executes tool_call and emits tool_result', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-1',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    // tool_call fires execution without awaiting (fire-and-forget for parallel execution),
+    // so we flush pending microtasks before asserting
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(onEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolCallId: 'tool-1',
+          success: true,
+          phase: MothershipStreamV1ToolPhase.result,
+        }),
+      })
+    )
+
+    const updated = context.toolCalls.get('tool-1')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.success)
+    expect(updated?.result?.output).toEqual({ ok: true })
+  })
+
+  it('updates stored params when a subagent generating event is followed by the final tool call', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    context.subAgentParentToolCallId = 'parent-1'
+    context.subAgentParentStack = ['parent-1']
+    context.toolCalls.set('parent-1', {
+      id: 'parent-1',
+      name: 'workflow',
+      status: 'pending',
+      startTime: Date.now(),
+    })
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'workflow' },
+        payload: {
+          toolCallId: 'sub-tool-1',
+          toolName: 'create_workflow',
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+          status: 'generating',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'workflow' },
+        payload: {
+          toolCallId: 'sub-tool-1',
+          toolName: 'create_workflow',
+          arguments: { name: 'Example Workflow' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+          status: 'executing',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledWith(
+      'create_workflow',
+      { name: 'Example Workflow' },
+      expect.any(Object)
+    )
+    expect(context.toolCalls.get('sub-tool-1')?.params).toEqual({ name: 'Example Workflow' })
+    expect(context.subAgentToolCalls['parent-1']?.[0]?.params).toEqual({
+      name: 'Example Workflow',
+    })
+  })
+
+  it('routes subagent text using the event scope parent tool call id', async () => {
+    context.subAgentParentToolCallId = 'wrong-parent'
+    context.subAgentContent['parent-1'] = ''
+
+    await subAgentHandlers.text(
+      {
+        type: MothershipStreamV1EventType.text,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'deploy' },
+        payload: {
+          channel: MothershipStreamV1TextChannel.assistant,
+          text: 'hello from deploy',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    expect(context.subAgentContent['parent-1']).toBe('hello from deploy')
+    expect(context.contentBlocks.at(-1)).toEqual(
+      expect.objectContaining({
+        type: 'subagent_text',
+        content: 'hello from deploy',
+      })
+    )
+  })
+
+  it('routes subagent tool calls using the event scope parent tool call id', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    context.subAgentParentToolCallId = 'wrong-parent'
+    context.toolCalls.set('parent-1', {
+      id: 'parent-1',
+      name: 'deploy',
+      status: 'pending',
+      startTime: Date.now(),
+    })
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'deploy' },
+        payload: {
+          toolCallId: 'sub-tool-scope-1',
+          toolName: 'read',
+          arguments: { path: 'workflow.json' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(context.subAgentToolCalls['parent-1']?.[0]?.id).toBe('sub-tool-scope-1')
+  })
+
+  it('skips duplicate tool_call after result', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+
+    const event = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'tool-dup',
+        toolName: ReadTool.id,
+        arguments: { workflowId: 'workflow-1' },
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.call,
+      },
+    }
+
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+  })
+
+  it('marks an in-flight tool as cancelled when aborted mid-execution', async () => {
+    const abortController = new AbortController()
+    const userStopController = new AbortController()
+    execContext.abortSignal = abortController.signal
+    execContext.userStopSignal = userStopController.signal
+
+    executeTool.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          setTimeout(() => resolve({ success: true, output: { ok: true } }), 0)
+        })
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-cancel',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      {
+        interactive: false,
+        timeout: 1000,
+        abortSignal: abortController.signal,
+        userStopSignal: userStopController.signal,
+      }
+    )
+
+    userStopController.abort()
+    abortController.abort()
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    const updated = context.toolCalls.get('tool-cancel')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.cancelled)
+  })
+
+  it('does not replace an in-flight pending promise on duplicate tool_call', async () => {
+    let resolveTool: ((value: { success: boolean; output: { ok: boolean } }) => void) | undefined
+    executeTool.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveTool = resolve
+        })
+    )
+
+    const event = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'tool-inflight',
+        toolName: ReadTool.id,
+        arguments: { workflowId: 'workflow-1' },
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.call,
+      },
+    }
+
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const firstPromise = context.pendingToolPromises.get('tool-inflight')
+    expect(firstPromise).toBeDefined()
+
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(context.pendingToolPromises.get('tool-inflight')).toBe(firstPromise)
+
+    resolveTool?.({ success: true, output: { ok: true } })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(context.pendingToolPromises.has('tool-inflight')).toBe(false)
+  })
+
+  it('still executes the tool when async row upsert fails', async () => {
+    upsertAsyncToolCall.mockRejectedValueOnce(new Error('db down'))
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-upsert-fail',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(context.toolCalls.get('tool-upsert-fail')?.status).toBe(
+      MothershipStreamV1ToolOutcome.success
+    )
+  })
+
+  it('does not execute a tool if a terminal tool_result arrives before local execution starts', async () => {
+    let resolveUpsert: ((value: null) => void) | undefined
+    upsertAsyncToolCall.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveUpsert = resolve
+        })
+    )
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-race',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-race',
+          toolName: ReadTool.id,
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.result,
+          success: true,
+          result: { ok: true },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    resolveUpsert?.(null)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).not.toHaveBeenCalled()
+    expect(context.toolCalls.get('tool-race')?.status).toBe(MothershipStreamV1ToolOutcome.success)
+    expect(context.toolCalls.get('tool-race')?.result?.output).toEqual({ ok: true })
+  })
+
+  it('does not execute a tool if a tool_result arrives before the tool_call event', async () => {
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-early-result',
+          toolName: ReadTool.id,
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.result,
+          success: true,
+          result: { ok: true },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-early-result',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).not.toHaveBeenCalled()
+    expect(context.toolCalls.get('tool-early-result')?.status).toBe(
+      MothershipStreamV1ToolOutcome.success
+    )
+  })
+
+  it('executes dynamic sim tools based on payload executor', async () => {
+    isSimExecuted.mockReturnValueOnce(false)
+    executeTool.mockResolvedValueOnce({ success: true, output: { emails: [] } })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-dynamic-sim',
+          toolName: 'gmail_read',
+          arguments: { maxResults: 10 },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledWith('gmail_read', { maxResults: 10 }, expect.any(Object))
+    expect(context.toolCalls.get('tool-dynamic-sim')?.status).toBe(
+      MothershipStreamV1ToolOutcome.success
+    )
+  })
+})
diff --git a/apps/sim/lib/copilot/request/handlers/index.ts b/apps/sim/lib/copilot/request/handlers/index.ts
new file mode 100644
index 00000000000..d416b1ace34
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/index.ts
@@ -0,0 +1,50 @@
+import { createLogger } from '@sim/logger'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent, StreamingContext } from '@/lib/copilot/request/types'
+import { handleCompleteEvent } from './complete'
+import { handleErrorEvent } from './error'
+import { handleRunEvent } from './run'
+import { handleSessionEvent } from './session'
+import { handleSpanEvent } from './span'
+import { handleTextEvent } from './text'
+import { handleToolEvent } from './tool'
+import type { StreamHandler } from './types'
+
+export type { StreamHandler, ToolScope } from './types'
+
+const logger = createLogger('CopilotHandlerRouting')
+
+export const sseHandlers: Record<string, StreamHandler> = {
+  [MothershipStreamV1EventType.session]: handleSessionEvent,
+  [MothershipStreamV1EventType.tool]: (e, c, ec, o) => handleToolEvent(e, c, ec, o, 'main'),
+  [MothershipStreamV1EventType.text]: handleTextEvent('main'),
+  [MothershipStreamV1EventType.run]: handleRunEvent,
+  [MothershipStreamV1EventType.complete]: handleCompleteEvent,
+  [MothershipStreamV1EventType.error]: handleErrorEvent,
+  [MothershipStreamV1EventType.span]: handleSpanEvent,
+}
+
+export const subAgentHandlers: Record<string, StreamHandler> = {
+  [MothershipStreamV1EventType.text]: handleTextEvent('subagent'),
+  [MothershipStreamV1EventType.tool]: (e, c, ec, o) => handleToolEvent(e, c, ec, o, 'subagent'),
+  [MothershipStreamV1EventType.span]: handleSpanEvent,
+}
+
+export function handleSubagentRouting(event: StreamEvent, context: StreamingContext): boolean {
+  if (event.scope?.lane !== 'subagent') return false
+
+  // Keep the latest scoped parent on hand for legacy callers, but subagent
+  // handlers should prefer the event-local scope for correctness.
+  if (event.scope?.parentToolCallId) {
+    context.subAgentParentToolCallId = event.scope.parentToolCallId
+  }
+
+  if (!context.subAgentParentToolCallId) {
+    logger.warn('Subagent event missing parent tool call', {
+      type: event.type,
+      subagent: event.scope?.agentId,
+    })
+    return false
+  }
+  return true
+}
diff --git a/apps/sim/lib/copilot/request/handlers/run.ts b/apps/sim/lib/copilot/request/handlers/run.ts
new file mode 100644
index 00000000000..9c9d41b0c3a
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/run.ts
@@ -0,0 +1,70 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1RunKind,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { getEventData } from '@/lib/copilot/request/sse-utils'
+import type { StreamHandler } from './types'
+import { addContentBlock } from './types'
+
+const logger = createLogger('CopilotRunHandler')
+
+export const handleRunEvent: StreamHandler = (event, context) => {
+  const d = getEventData(event)
+  if (!d) return
+
+  const kind = d?.kind as string | undefined
+
+  if (kind === MothershipStreamV1RunKind.checkpoint_pause) {
+    const rawFrames = Array.isArray(d?.frames) ? d.frames : []
+    const frames = rawFrames.map((f: Record<string, unknown>) => ({
+      parentToolCallId: String(f.parentToolCallId),
+      parentToolName: String(f.parentToolName ?? ''),
+      pendingToolIds: Array.isArray(f.pendingToolIds)
+        ? f.pendingToolIds.map((id: unknown) => String(id))
+        : [],
+    }))
+
+    context.awaitingAsyncContinuation = {
+      checkpointId: String(d?.checkpointId),
+      executionId: typeof d?.executionId === 'string' ? d.executionId : context.executionId,
+      runId: typeof d?.runId === 'string' && d.runId ? d.runId : context.runId,
+      pendingToolCallIds: Array.isArray(d?.pendingToolCallIds)
+        ? d.pendingToolCallIds.map((id) => String(id))
+        : [],
+      frames: frames.length > 0 ? frames : undefined,
+    }
+    logger.info('Received checkpoint pause', {
+      checkpointId: context.awaitingAsyncContinuation.checkpointId,
+      executionId: context.awaitingAsyncContinuation.executionId,
+      runId: context.awaitingAsyncContinuation.runId,
+      pendingToolCallIds: context.awaitingAsyncContinuation.pendingToolCallIds,
+      frameCount: frames.length,
+    })
+    context.streamComplete = true
+    return
+  }
+
+  if (kind === MothershipStreamV1RunKind.compaction_start) {
+    addContentBlock(context, {
+      type: 'tool_call',
+      toolCall: {
+        id: `compaction-${Date.now()}`,
+        name: 'context_compaction',
+        status: 'executing',
+      },
+    })
+    return
+  }
+
+  if (kind === MothershipStreamV1RunKind.compaction_done) {
+    addContentBlock(context, {
+      type: 'tool_call',
+      toolCall: {
+        id: `compaction-${Date.now()}`,
+        name: 'context_compaction',
+        status: MothershipStreamV1ToolOutcome.success,
+      },
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/session.ts b/apps/sim/lib/copilot/request/handlers/session.ts
new file mode 100644
index 00000000000..72ad666a85a
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/session.ts
@@ -0,0 +1,14 @@
+import { MothershipStreamV1SessionKind } from '@/lib/copilot/generated/mothership-stream-v1'
+import { getEventData } from '@/lib/copilot/request/sse-utils'
+import type { StreamHandler } from './types'
+
+export const handleSessionEvent: StreamHandler = (event, context, execContext) => {
+  const data = getEventData(event)
+  if (data?.kind === MothershipStreamV1SessionKind.chat) {
+    const chatId = data.chatId as string | undefined
+    context.chatId = chatId
+    if (chatId) {
+      execContext.chatId = chatId
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/span.ts b/apps/sim/lib/copilot/request/handlers/span.ts
new file mode 100644
index 00000000000..e684b232582
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/span.ts
@@ -0,0 +1,3 @@
+import type { StreamHandler } from './types'
+
+export const handleSpanEvent: StreamHandler = () => {}
diff --git a/apps/sim/lib/copilot/request/handlers/text.ts b/apps/sim/lib/copilot/request/handlers/text.ts
new file mode 100644
index 00000000000..7c42b68516e
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/text.ts
@@ -0,0 +1,54 @@
+import {
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { getEventData } from '@/lib/copilot/request/sse-utils'
+import type { StreamHandler, ToolScope } from './types'
+import { addContentBlock, getScopedParentToolCallId } from './types'
+
+export function handleTextEvent(scope: ToolScope): StreamHandler {
+  return (event, context) => {
+    const d = getEventData(event)
+
+    if (scope === 'subagent') {
+      const parentToolCallId = getScopedParentToolCallId(event, context)
+      if (!parentToolCallId || d?.channel !== MothershipStreamV1TextChannel.assistant) return
+      const chunk = d?.text as string | undefined
+      if (!chunk) return
+      context.subAgentContent[parentToolCallId] =
+        (context.subAgentContent[parentToolCallId] || '') + chunk
+      addContentBlock(context, { type: 'subagent_text', content: chunk })
+      return
+    }
+
+    if (d?.channel === MothershipStreamV1TextChannel.thinking) {
+      const phase = d.phase as string | undefined
+      if (phase === MothershipStreamV1SpanLifecycleEvent.start) {
+        context.isInThinkingBlock = true
+        context.currentThinkingBlock = {
+          type: 'thinking',
+          content: '',
+          timestamp: Date.now(),
+        }
+        return
+      }
+      if (phase === MothershipStreamV1SpanLifecycleEvent.end) {
+        if (context.currentThinkingBlock) {
+          context.contentBlocks.push(context.currentThinkingBlock)
+        }
+        context.isInThinkingBlock = false
+        context.currentThinkingBlock = null
+        return
+      }
+      const chunk = d?.text as string | undefined
+      if (!chunk || !context.currentThinkingBlock) return
+      context.currentThinkingBlock.content = `${context.currentThinkingBlock.content || ''}${chunk}`
+      return
+    }
+
+    const chunk = d?.text as string | undefined
+    if (!chunk) return
+    context.accumulatedContent += chunk
+    addContentBlock(context, { type: 'text', content: chunk })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/tool.ts b/apps/sim/lib/copilot/request/handlers/tool.ts
new file mode 100644
index 00000000000..6c9a1cc4f6f
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/tool.ts
@@ -0,0 +1,395 @@
+import { createLogger } from '@sim/logger'
+import { upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
+import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { TOOL_CALL_STATUS } from '@/lib/copilot/request/session'
+import {
+  asRecord,
+  getEventData,
+  markToolResultSeen,
+  wasToolResultSeen,
+} from '@/lib/copilot/request/sse-utils'
+import { executeToolAndReport, waitForToolCompletion } from '@/lib/copilot/request/tools/executor'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+  ToolCallState,
+} from '@/lib/copilot/request/types'
+import { getToolEntry, isSimExecuted } from '@/lib/copilot/tool-executor'
+import { isWorkflowToolName } from '@/lib/copilot/tools/workflow-tools'
+import type { ToolScope } from './types'
+import {
+  abortPendingToolIfStreamDead,
+  addContentBlock,
+  emitSyntheticToolResult,
+  ensureTerminalToolCallState,
+  getEventUI,
+  getScopedParentToolCallId,
+  handleClientCompletion,
+  inferToolSuccess,
+  registerPendingToolPromise,
+} from './types'
+
+const logger = createLogger('CopilotToolHandler')
+
+/**
+ * Unified tool event handler for both main and subagent scopes.
+ *
+ * The main vs subagent differences are:
+ * - Subagent requires a parentToolCallId and tracks tool calls in subAgentToolCalls
+ * - Subagent result phase also updates the subAgentToolCalls record
+ * - Subagent call phase stores in both subAgentToolCalls and context.toolCalls
+ * - Main call phase only stores in context.toolCalls
+ */
+export async function handleToolEvent(
+  event: StreamEvent,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  scope: ToolScope
+): Promise<void> {
+  const isSubagent = scope === 'subagent'
+  const parentToolCallId = isSubagent ? getScopedParentToolCallId(event, context) : undefined
+
+  if (isSubagent && !parentToolCallId) return
+
+  const data = getEventData(event)
+  const phase = data?.phase as string | undefined
+  const toolCallId = (data?.toolCallId as string | undefined) || (data?.id as string | undefined)
+  if (!toolCallId) return
+  const toolName =
+    (data?.toolName as string | undefined) ||
+    (data?.name as string | undefined) ||
+    context.toolCalls.get(toolCallId)?.name ||
+    ''
+
+  if (phase === MothershipStreamV1ToolPhase.args_delta) {
+    return
+  }
+
+  if (phase === MothershipStreamV1ToolPhase.result) {
+    handleResultPhase(context, data, toolCallId, toolName, isSubagent, parentToolCallId)
+    return
+  }
+
+  handleCallPhase(
+    event,
+    context,
+    execContext,
+    options,
+    data,
+    toolCallId,
+    toolName,
+    isSubagent,
+    parentToolCallId,
+    scope
+  )
+}
+
+function handleResultPhase(
+  context: StreamingContext,
+  data: Record<string, unknown> | undefined,
+  toolCallId: string,
+  toolName: string,
+  isSubagent: boolean,
+  parentToolCallId: string | undefined
+): void {
+  const mainToolCall = ensureTerminalToolCallState(context, toolCallId, toolName)
+  const { success, hasResultData, hasError } = inferToolSuccess(data)
+  const status =
+    data?.status === MothershipStreamV1ToolOutcome.cancelled
+      ? MothershipStreamV1ToolOutcome.cancelled
+      : success
+        ? MothershipStreamV1ToolOutcome.success
+        : MothershipStreamV1ToolOutcome.error
+  const endTime = Date.now()
+  const result = hasResultData ? { success, output: data?.result || data?.data } : undefined
+
+  if (isSubagent && parentToolCallId) {
+    const toolCalls = context.subAgentToolCalls[parentToolCallId] || []
+    const subAgentToolCall = toolCalls.find((tc) => tc.id === toolCallId)
+    if (subAgentToolCall) {
+      subAgentToolCall.status = status
+      subAgentToolCall.endTime = endTime
+      if (result) subAgentToolCall.result = result
+      if (hasError) {
+        const resultObj = asRecord(data?.result)
+        subAgentToolCall.error = (data?.error || resultObj.error) as string | undefined
+      }
+    }
+  }
+
+  mainToolCall.status = status
+  mainToolCall.endTime = endTime
+  if (result) mainToolCall.result = result
+  if (hasError) {
+    const resultObj = asRecord(data?.result)
+    mainToolCall.error = (data?.error || resultObj.error) as string | undefined
+  }
+  markToolResultSeen(toolCallId)
+}
+
+async function handleCallPhase(
+  event: StreamEvent,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  data: Record<string, unknown> | undefined,
+  toolCallId: string,
+  toolName: string,
+  isSubagent: boolean,
+  parentToolCallId: string | undefined,
+  scope: ToolScope
+): Promise<void> {
+  const args = (data?.arguments || data?.input) as Record<string, unknown> | undefined
+  const isGenerating = data?.status === TOOL_CALL_STATUS.generating
+  const isPartial = data?.partial === true || isGenerating
+  const existing = context.toolCalls.get(toolCallId)
+
+  if (isSubagent) {
+    if (wasToolResultSeen(toolCallId) || existing?.endTime) {
+      if (existing && !existing.name && toolName) existing.name = toolName
+      if (existing && !existing.params && args) existing.params = args
+      return
+    }
+  } else {
+    if (
+      existing?.endTime ||
+      (existing && existing.status !== 'pending' && existing.status !== 'executing')
+    ) {
+      if (!existing.name && toolName) existing.name = toolName
+      if (!existing.params && args) existing.params = args
+      return
+    }
+  }
+
+  if (isSubagent) {
+    registerSubagentToolCall(context, toolCallId, toolName, args, parentToolCallId!)
+  } else {
+    registerMainToolCall(context, toolCallId, toolName, args, existing)
+  }
+
+  if (isPartial) return
+  if (!isSubagent && wasToolResultSeen(toolCallId)) return
+  if (context.pendingToolPromises.has(toolCallId) || existing?.status === 'executing') {
+    return
+  }
+
+  const toolCall = context.toolCalls.get(toolCallId)
+  if (!toolCall) return
+
+  const isGoHandledInternalRead =
+    toolName === 'read' &&
+    typeof args?.path === 'string' &&
+    (args.path as string).startsWith('internal/')
+  if (isGoHandledInternalRead) return
+
+  const { clientExecutable, simExecutable, internal } = getEventUI(event)
+  const catalogEntry = getToolEntry(toolName)
+  const isInternal = internal || catalogEntry?.internal === true
+  const staticSimExecuted = isSimExecuted(toolName)
+  const willDispatch = !isInternal && (staticSimExecuted || simExecutable || clientExecutable)
+  logger.info('Tool call routing decision', {
+    toolCallId,
+    toolName,
+    scope,
+    isSubagent,
+    parentToolCallId,
+    executor: data?.executor,
+    clientExecutable,
+    simExecutable,
+    staticSimExecuted,
+    internal: isInternal,
+    hasPendingPromise: context.pendingToolPromises.has(toolCallId),
+    existingStatus: existing?.status,
+    willDispatch,
+  })
+  if (isInternal) return
+  if (!willDispatch) return
+
+  await dispatchToolExecution(
+    toolCall,
+    toolCallId,
+    toolName,
+    args,
+    context,
+    execContext,
+    options,
+    clientExecutable,
+    scope
+  )
+}
+
+function registerSubagentToolCall(
+  context: StreamingContext,
+  toolCallId: string,
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+  parentToolCallId: string
+): void {
+  if (!context.subAgentToolCalls[parentToolCallId]) {
+    context.subAgentToolCalls[parentToolCallId] = []
+  }
+  let toolCall = context.toolCalls.get(toolCallId)
+  if (toolCall) {
+    if (!toolCall.name && toolName) toolCall.name = toolName
+    if (args && !toolCall.params) toolCall.params = args
+  } else {
+    toolCall = {
+      id: toolCallId,
+      name: toolName,
+      status: 'pending',
+      params: args,
+      startTime: Date.now(),
+    }
+    context.toolCalls.set(toolCallId, toolCall)
+    const parentToolCall = context.toolCalls.get(parentToolCallId)
+    addContentBlock(context, {
+      type: 'tool_call',
+      toolCall,
+      calledBy: parentToolCall?.name,
+    })
+  }
+
+  const subagentToolCalls = context.subAgentToolCalls[parentToolCallId]
+  const existingSubagentToolCall = subagentToolCalls.find((tc) => tc.id === toolCallId)
+  if (existingSubagentToolCall) {
+    if (!existingSubagentToolCall.name && toolName) existingSubagentToolCall.name = toolName
+    if (args && !existingSubagentToolCall.params) existingSubagentToolCall.params = args
+  } else {
+    subagentToolCalls.push(toolCall)
+  }
+}
+
+function registerMainToolCall(
+  context: StreamingContext,
+  toolCallId: string,
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+  existing: ToolCallState | undefined
+): void {
+  if (existing) {
+    if (args && !existing.params) existing.params = args
+    if (
+      !context.contentBlocks.some((b) => b.type === 'tool_call' && b.toolCall?.id === toolCallId)
+    ) {
+      addContentBlock(context, { type: 'tool_call', toolCall: existing })
+    }
+  } else {
+    const created: ToolCallState = {
+      id: toolCallId,
+      name: toolName,
+      status: 'pending',
+      params: args,
+      startTime: Date.now(),
+    }
+    context.toolCalls.set(toolCallId, created)
+    addContentBlock(context, { type: 'tool_call', toolCall: created })
+  }
+}
+
+async function dispatchToolExecution(
+  toolCall: ToolCallState,
+  toolCallId: string,
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  clientExecutable: boolean,
+  scope: ToolScope
+): Promise<void> {
+  const scopeLabel = scope === 'subagent' ? 'subagent ' : ''
+
+  const fireToolExecution = () => {
+    const pendingPromise = (async () => {
+      return executeToolAndReport(toolCallId, context, execContext, options)
+    })().catch((err) => {
+      logger.error(`Parallel ${scopeLabel}tool execution failed`, {
+        toolCallId,
+        toolName,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return {
+        status: MothershipStreamV1ToolOutcome.error,
+        message: 'Tool execution failed',
+        data: { error: 'Tool execution failed' },
+      }
+    })
+    registerPendingToolPromise(context, toolCallId, pendingPromise)
+  }
+
+  if (options.interactive === false) {
+    if (options.autoExecuteTools !== false) {
+      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
+        fireToolExecution()
+      }
+    }
+    return
+  }
+
+  if (clientExecutable) {
+    const delegateWorkflowRunToClient = isWorkflowToolName(toolName)
+    if (isSimExecuted(toolName) && !delegateWorkflowRunToClient) {
+      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
+        fireToolExecution()
+      }
+    } else {
+      toolCall.status = 'executing'
+      const pendingPromise = (async () => {
+        await upsertAsyncToolCall({
+          runId: context.runId || crypto.randomUUID(),
+          toolCallId,
+          toolName,
+          args,
+          status: MothershipStreamV1AsyncToolRecordStatus.running,
+        }).catch((err) => {
+          logger.warn(`Failed to persist async tool row for client-executable ${scopeLabel}tool`, {
+            toolCallId,
+            toolName,
+            error: err instanceof Error ? err.message : String(err),
+          })
+        })
+        const completion = await waitForToolCompletion(
+          toolCallId,
+          options.timeout || STREAM_TIMEOUT_MS,
+          options.abortSignal
+        )
+        handleClientCompletion(toolCall, toolCallId, completion)
+        await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options)
+        return (
+          completion ?? {
+            status: MothershipStreamV1ToolOutcome.error,
+            message: 'Tool completion missing',
+            data: { error: 'Tool completion missing' },
+          }
+        )
+      })().catch((err) => {
+        logger.error(`Client-executable ${scopeLabel}tool wait failed`, {
+          toolCallId,
+          toolName,
+          error: err instanceof Error ? err.message : String(err),
+        })
+        return {
+          status: MothershipStreamV1ToolOutcome.error,
+          message: 'Tool wait failed',
+          data: { error: 'Tool wait failed' },
+        }
+      })
+      registerPendingToolPromise(context, toolCallId, pendingPromise)
+    }
+    return
+  }
+
+  if (options.autoExecuteTools !== false) {
+    if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
+      fireToolExecution()
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/types.ts b/apps/sim/lib/copilot/request/handlers/types.ts
new file mode 100644
index 00000000000..53722f7548f
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/types.ts
@@ -0,0 +1,229 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1EventType,
+  type MothershipStreamV1StreamScope,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { asRecord, getEventData, markToolResultSeen } from '@/lib/copilot/request/sse-utils'
+import type {
+  ContentBlock,
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+  ToolCallState,
+} from '@/lib/copilot/request/types'
+
+export type StreamHandler = (
+  event: StreamEvent,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions
+) => void | Promise<void>
+
+export type ToolScope = MothershipStreamV1StreamScope['lane']
+
+const logger = createLogger('CopilotHandlerHelpers')
+
+export function addContentBlock(
+  context: StreamingContext,
+  block: Omit<ContentBlock, 'timestamp'>
+): void {
+  context.contentBlocks.push({
+    ...block,
+    timestamp: Date.now(),
+  })
+}
+
+export function getScopedParentToolCallId(
+  event: StreamEvent,
+  context: StreamingContext
+): string | undefined {
+  return event.scope?.parentToolCallId || context.subAgentParentToolCallId
+}
+
+export function registerPendingToolPromise(
+  context: StreamingContext,
+  toolCallId: string,
+  pendingPromise: Promise<{ status: string; message?: string; data?: Record<string, unknown> }>
+): void {
+  context.pendingToolPromises.set(toolCallId, pendingPromise)
+  pendingPromise.finally(() => {
+    if (context.pendingToolPromises.get(toolCallId) === pendingPromise) {
+      context.pendingToolPromises.delete(toolCallId)
+    }
+  })
+}
+
+/**
+ * When the Sim->Go stream is aborted, avoid starting server-side tool work and
+ * unblock the Go async waiter with a terminal 499 completion.
+ */
+export function abortPendingToolIfStreamDead(
+  toolCall: ToolCallState,
+  toolCallId: string,
+  options: OrchestratorOptions,
+  context: StreamingContext
+): boolean {
+  if (!options.abortSignal?.aborted && !context.wasAborted) {
+    return false
+  }
+  toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+  toolCall.endTime = Date.now()
+  markToolResultSeen(toolCallId)
+  return true
+}
+
+/**
+ * Extract the `ui` object from a Go SSE event. The Go backend enriches
+ * tool_call events with `ui: { requiresConfirmation, clientExecutable, ... }`.
+ */
+export function getEventUI(event: StreamEvent): {
+  requiresConfirmation: boolean
+  clientExecutable: boolean
+  simExecutable: boolean
+  internal: boolean
+  hidden: boolean
+} {
+  const data = getEventData(event)
+  const raw = asRecord(data?.ui)
+  return {
+    requiresConfirmation: raw.requiresConfirmation === true || data?.requiresConfirmation === true,
+    clientExecutable:
+      raw.clientExecutable === true || data?.executor === MothershipStreamV1ToolExecutor.client,
+    simExecutable: data?.executor === MothershipStreamV1ToolExecutor.sim,
+    internal: raw.internal === true,
+    hidden: raw.hidden === true,
+  }
+}
+
+/**
+ * Handle the completion signal from a client-executable tool.
+ * Shared by both main and subagent scopes.
+ */
+export function handleClientCompletion(
+  toolCall: ToolCallState,
+  toolCallId: string,
+  completion: { status: string; message?: string; data?: Record<string, unknown> } | null
+): void {
+  if (completion?.status === 'background') {
+    toolCall.status = MothershipStreamV1ToolOutcome.skipped
+    toolCall.result = completion?.data ? { success: true, output: completion.data } : undefined
+    toolCall.endTime = Date.now()
+    markToolResultSeen(toolCallId)
+    return
+  }
+  if (completion?.status === MothershipStreamV1ToolOutcome.rejected) {
+    toolCall.status = MothershipStreamV1ToolOutcome.rejected
+    toolCall.error = completion?.message || 'Tool rejected'
+    toolCall.result = {
+      success: false,
+      output: completion?.data ?? { error: toolCall.error },
+    }
+    toolCall.endTime = Date.now()
+    markToolResultSeen(toolCallId)
+    return
+  }
+  if (completion?.status === MothershipStreamV1ToolOutcome.cancelled) {
+    toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+    toolCall.error = completion?.message || 'Tool cancelled'
+    toolCall.result = {
+      success: false,
+      output: completion?.data ?? { error: toolCall.error },
+    }
+    toolCall.endTime = Date.now()
+    markToolResultSeen(toolCallId)
+    return
+  }
+  const success = completion?.status === MothershipStreamV1ToolOutcome.success
+  toolCall.status = success
+    ? MothershipStreamV1ToolOutcome.success
+    : MothershipStreamV1ToolOutcome.error
+  toolCall.result = {
+    success,
+    output: completion?.data ?? (success ? {} : { error: completion?.message || 'Tool failed' }),
+  }
+  toolCall.error = success ? undefined : completion?.message || 'Tool failed'
+  toolCall.endTime = Date.now()
+  markToolResultSeen(toolCallId)
+}
+
+/**
+ * Emit a synthetic tool_result SSE event to the client after a client-executable
+ * tool completes. The Go backend's actual tool_result is skipped (markToolResultSeen),
+ * so the client would never learn the outcome without this.
+ */
+export async function emitSyntheticToolResult(
+  toolCallId: string,
+  toolName: string,
+  completion: { status: string; message?: string; data?: Record<string, unknown> } | null,
+  options: OrchestratorOptions
+): Promise<void> {
+  const success = completion?.status === MothershipStreamV1ToolOutcome.success
+  const isCancelled = completion?.status === MothershipStreamV1ToolOutcome.cancelled
+
+  const resultPayload = isCancelled
+    ? { ...completion?.data, reason: 'user_cancelled', cancelledByUser: true }
+    : completion?.data
+
+  try {
+    await options.onEvent?.({
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId,
+        toolName,
+        executor: MothershipStreamV1ToolExecutor.client,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        success,
+        result: resultPayload,
+        ...(completion?.status ? { status: completion.status } : {}),
+        ...(!success && completion?.message ? { error: completion.message } : {}),
+      },
+    })
+  } catch (error) {
+    logger.warn('Failed to emit synthetic tool_result', {
+      toolCallId,
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+export function inferToolSuccess(data: Record<string, unknown> | undefined): {
+  success: boolean
+  hasResultData: boolean
+  hasError: boolean
+} {
+  const resultObj = asRecord(data?.result)
+  const hasExplicitSuccess = data?.success !== undefined || resultObj.success !== undefined
+  const explicitSuccess = data?.success ?? resultObj.success
+  const hasResultData = data?.result !== undefined || data?.data !== undefined
+  const hasError = !!data?.error || !!resultObj.error
+  const success = hasExplicitSuccess ? !!explicitSuccess : !hasError
+  return { success, hasResultData, hasError }
+}
+
+export function ensureTerminalToolCallState(
+  context: StreamingContext,
+  toolCallId: string,
+  toolName: string
+): ToolCallState {
+  const existing = context.toolCalls.get(toolCallId)
+  if (existing) {
+    return existing
+  }
+
+  const toolCall: ToolCallState = {
+    id: toolCallId,
+    name: toolName || 'unknown_tool',
+    status: 'pending',
+    startTime: Date.now(),
+  }
+  context.toolCalls.set(toolCallId, toolCall)
+  addContentBlock(context, { type: 'tool_call', toolCall })
+  return toolCall
+}
diff --git a/apps/sim/lib/copilot/request-helpers.ts b/apps/sim/lib/copilot/request/http.ts
similarity index 63%
rename from apps/sim/lib/copilot/request-helpers.ts
rename to apps/sim/lib/copilot/request/http.ts
index 0e7be51df41..bd5d7e518fc 100644
--- a/apps/sim/lib/copilot/request-helpers.ts
+++ b/apps/sim/lib/copilot/request/http.ts
@@ -1,9 +1,21 @@
+import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
+import { env } from '@/lib/core/config/env'
+import { safeCompare } from '@/lib/core/security/encryption'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { generateId } from '@/lib/core/utils/uuid'
 
-export type { NotificationStatus } from '@/lib/copilot/types'
+export const NotificationStatus = {
+  pending: 'pending',
+  success: 'success',
+  error: 'error',
+  accepted: 'accepted',
+  rejected: 'rejected',
+  background: 'background',
+  cancelled: 'cancelled',
+} as const
+export type NotificationStatus = (typeof NotificationStatus)[keyof typeof NotificationStatus]
 
 export interface CopilotAuthResult {
   userId: string | null
@@ -62,3 +74,22 @@ export async function authenticateCopilotRequestSessionOnly(): Promise<CopilotAu
     isAuthenticated: userId !== null,
   }
 }
+
+export function checkInternalApiKey(req: NextRequest) {
+  const apiKey = req.headers.get('x-api-key')
+  const expectedApiKey = env.INTERNAL_API_SECRET
+
+  if (!expectedApiKey) {
+    return { success: false, error: 'Internal API key not configured' }
+  }
+
+  if (!apiKey) {
+    return { success: false, error: 'API key required' }
+  }
+
+  if (!safeCompare(apiKey, expectedApiKey)) {
+    return { success: false, error: 'Invalid API key' }
+  }
+
+  return { success: true }
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/finalize.ts b/apps/sim/lib/copilot/request/lifecycle/finalize.ts
new file mode 100644
index 00000000000..88c35e509e8
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/finalize.ts
@@ -0,0 +1,119 @@
+import { createLogger } from '@sim/logger'
+import { updateRunStatus } from '@/lib/copilot/async-runs/repository'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamWriter } from '@/lib/copilot/request/session'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+
+const logger = createLogger('CopilotStreamFinalize')
+
+/**
+ * Single finalization path for stream results.
+ * Handles abort / error / success and publishes the terminal event.
+ * Replaces duplicated blocks in the old chat-streaming.ts.
+ */
+export async function finalizeStream(
+  result: OrchestratorResult,
+  publisher: StreamWriter,
+  runId: string,
+  aborted: boolean,
+  requestId: string
+): Promise<void> {
+  if (aborted) {
+    return handleAborted(publisher, runId, requestId)
+  }
+  if (!result.success) {
+    return handleError(result, publisher, runId, requestId)
+  }
+  return handleSuccess(publisher, runId, requestId)
+}
+
+async function handleAborted(
+  publisher: StreamWriter,
+  runId: string,
+  requestId: string
+): Promise<void> {
+  logger.info(`[${requestId}] Stream aborted by explicit stop`)
+  if (!publisher.sawComplete) {
+    await publisher.publish({
+      type: MothershipStreamV1EventType.complete,
+      payload: { status: MothershipStreamV1CompletionStatus.cancelled },
+    })
+  }
+  await publisher.flush()
+  await loggedRunStatusUpdate(runId, MothershipStreamV1CompletionStatus.cancelled, requestId, {
+    completedAt: new Date(),
+  })
+}
+
+async function handleError(
+  result: OrchestratorResult,
+  publisher: StreamWriter,
+  runId: string,
+  requestId: string
+): Promise<void> {
+  const errorMessage =
+    result.error ||
+    result.errors?.[0] ||
+    'An unexpected error occurred while processing the response.'
+
+  if (publisher.clientDisconnected) {
+    logger.info(`[${requestId}] Stream failed after client disconnect`, { error: errorMessage })
+  }
+  logger.error(`[${requestId}] Orchestration returned failure`, { error: errorMessage })
+
+  await publisher.publish({
+    type: MothershipStreamV1EventType.error,
+    payload: {
+      message: errorMessage,
+      error: errorMessage,
+      data: { displayMessage: 'An unexpected error occurred while processing the response.' },
+    },
+  })
+  if (!publisher.sawComplete) {
+    await publisher.publish({
+      type: MothershipStreamV1EventType.complete,
+      payload: { status: MothershipStreamV1CompletionStatus.error },
+    })
+  }
+  await publisher.flush()
+  await loggedRunStatusUpdate(runId, MothershipStreamV1CompletionStatus.error, requestId, {
+    completedAt: new Date(),
+    error: errorMessage,
+  })
+}
+
+async function handleSuccess(
+  publisher: StreamWriter,
+  runId: string,
+  requestId: string
+): Promise<void> {
+  if (!publisher.sawComplete) {
+    await publisher.publish({
+      type: MothershipStreamV1EventType.complete,
+      payload: { status: MothershipStreamV1CompletionStatus.complete },
+    })
+  }
+  await publisher.flush()
+  await loggedRunStatusUpdate(runId, MothershipStreamV1CompletionStatus.complete, requestId, {
+    completedAt: new Date(),
+  })
+}
+
+async function loggedRunStatusUpdate(
+  runId: string,
+  status: Parameters<typeof updateRunStatus>[1],
+  requestId: string,
+  updates: Parameters<typeof updateRunStatus>[2] = {}
+): Promise<void> {
+  try {
+    await updateRunStatus(runId, status, updates)
+  } catch (error) {
+    logger.warn(`[${requestId}] Failed to update run status to ${status}`, {
+      runId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/run.ts b/apps/sim/lib/copilot/request/lifecycle/run.ts
new file mode 100644
index 00000000000..f5d15cf7673
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/run.ts
@@ -0,0 +1,427 @@
+import { createLogger } from '@sim/logger'
+import { updateRunStatus } from '@/lib/copilot/async-runs/repository'
+import { SIM_AGENT_API_URL, SIM_AGENT_VERSION } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1RunKind,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
+import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
+import {
+  BillingLimitError,
+  CopilotBackendError,
+  runStreamLoop,
+} from '@/lib/copilot/request/go/stream'
+import { handleBillingLimitResponse } from '@/lib/copilot/request/tools/billing'
+import { executeToolAndReport } from '@/lib/copilot/request/tools/executor'
+import type { TraceCollector } from '@/lib/copilot/request/trace'
+import { RequestTraceV1SpanStatus } from '@/lib/copilot/request/trace'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  OrchestratorResult,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
+import { env } from '@/lib/core/config/env'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+
+const logger = createLogger('CopilotLifecycle')
+
+const MAX_RESUME_ATTEMPTS = 3
+const RESUME_BACKOFF_MS = [250, 500, 1000] as const
+
+export interface CopilotLifecycleOptions extends OrchestratorOptions {
+  userId: string
+  workflowId?: string
+  workspaceId?: string
+  chatId?: string
+  executionId?: string
+  runId?: string
+  goRoute?: string
+  trace?: TraceCollector
+  simRequestId?: string
+}
+
+export async function runCopilotLifecycle(
+  requestPayload: Record<string, unknown>,
+  options: CopilotLifecycleOptions
+): Promise<OrchestratorResult> {
+  const {
+    userId,
+    workflowId,
+    workspaceId,
+    chatId,
+    executionId,
+    runId,
+    goRoute = '/api/copilot',
+  } = options
+
+  const execContext = await buildExecutionContext(requestPayload, {
+    userId,
+    workflowId,
+    workspaceId,
+    chatId,
+    executionId,
+    runId,
+    abortSignal: options.abortSignal,
+  })
+
+  const payloadMsgId = requestPayload?.messageId
+  const context = createStreamingContext({
+    chatId,
+    executionId,
+    runId,
+    messageId: typeof payloadMsgId === 'string' ? payloadMsgId : crypto.randomUUID(),
+    ...(options.trace ? { trace: options.trace } : {}),
+  })
+
+  try {
+    await runCheckpointLoop(requestPayload, context, execContext, options, goRoute)
+
+    const result: OrchestratorResult = {
+      success: context.errors.length === 0 && !context.wasAborted,
+      content: context.accumulatedContent,
+      contentBlocks: context.contentBlocks,
+      toolCalls: buildToolCallSummaries(context),
+      chatId: context.chatId,
+      requestId: context.requestId,
+      errors: context.errors.length ? context.errors : undefined,
+      usage: context.usage,
+      cost: context.cost,
+    }
+    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,
+      error: err.message,
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Checkpoint loop – the core state machine
+// ---------------------------------------------------------------------------
+
+async function runCheckpointLoop(
+  initialPayload: Record<string, unknown>,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: CopilotLifecycleOptions,
+  initialRoute: string
+): Promise<void> {
+  let route = initialRoute
+  let payload: Record<string, unknown> = initialPayload
+  let resumeAttempt = 0
+  const callerOnEvent = options.onEvent
+
+  for (;;) {
+    context.streamComplete = false
+    const isResume = route === '/api/tools/resume'
+
+    if (isResume && isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const loopOptions = {
+      ...options,
+      onEvent: async (event: StreamEvent) => {
+        if (
+          event.type === MothershipStreamV1EventType.run &&
+          event.payload.kind === MothershipStreamV1RunKind.checkpoint_pause &&
+          options.runId
+        ) {
+          try {
+            await updateRunStatus(options.runId, 'paused_waiting_for_tool')
+          } catch (error) {
+            logger.warn('Failed to mark run as paused_waiting_for_tool', {
+              runId: options.runId,
+              error: error instanceof Error ? error.message : String(error),
+            })
+          }
+        }
+        await callerOnEvent?.(event)
+      },
+    }
+
+    const streamSpan = context.trace.startSpan(
+      isResume ? 'Sim → Go (Resume)' : 'Sim → Go Stream',
+      isResume ? 'lifecycle.resume' : 'sim.stream',
+      {
+        route,
+        isResume,
+        ...(isResume ? { attempt: resumeAttempt } : {}),
+      }
+    )
+    context.trace.setActiveSpan(streamSpan)
+
+    logger.info('Starting stream loop', {
+      route,
+      isResume,
+      resumeAttempt,
+      pendingToolPromises: context.pendingToolPromises.size,
+      toolCallCount: context.toolCalls.size,
+      hasCheckpoint: !!context.awaitingAsyncContinuation,
+    })
+
+    try {
+      await runStreamLoop(
+        `${SIM_AGENT_API_URL}${route}`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+            'X-Client-Version': SIM_AGENT_VERSION,
+            ...(options.simRequestId ? { 'X-Sim-Request-ID': options.simRequestId } : {}),
+          },
+          body: JSON.stringify(payload),
+        },
+        context,
+        execContext,
+        loopOptions
+      )
+      context.trace.endSpan(streamSpan)
+      resumeAttempt = 0
+    } catch (streamError) {
+      context.trace.endSpan(streamSpan, RequestTraceV1SpanStatus.error)
+      if (streamError instanceof BillingLimitError) {
+        await handleBillingLimitResponse(streamError.userId, context, execContext, options)
+        break
+      }
+      if (
+        isResume &&
+        isRetryableStreamError(streamError) &&
+        resumeAttempt < MAX_RESUME_ATTEMPTS - 1
+      ) {
+        resumeAttempt++
+        const backoff = RESUME_BACKOFF_MS[resumeAttempt - 1] ?? 1000
+        logger.warn('Resume stream failed, retrying', {
+          attempt: resumeAttempt + 1,
+          maxAttempts: MAX_RESUME_ATTEMPTS,
+          backoffMs: backoff,
+          error: streamError instanceof Error ? streamError.message : String(streamError),
+        })
+        await sleepWithAbort(backoff, options.abortSignal)
+        continue
+      }
+      throw streamError
+    }
+
+    logger.info('Stream loop completed', {
+      route,
+      isResume,
+      isAborted: isAborted(options, context),
+      hasCheckpoint: !!context.awaitingAsyncContinuation,
+      checkpointId: context.awaitingAsyncContinuation?.checkpointId,
+      pendingToolPromises: context.pendingToolPromises.size,
+      streamComplete: context.streamComplete,
+      toolCallCount: context.toolCalls.size,
+    })
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const continuation = context.awaitingAsyncContinuation
+    if (!continuation) break
+
+    if (context.pendingToolPromises.size > 0) {
+      const waitSpan = context.trace.startSpan('Wait for Tools', 'lifecycle.wait_tools', {
+        checkpointId: continuation.checkpointId,
+        pendingCount: context.pendingToolPromises.size,
+      })
+      logger.info('Waiting for in-flight tool executions before resume', {
+        checkpointId: continuation.checkpointId,
+        pendingCount: context.pendingToolPromises.size,
+      })
+      await Promise.allSettled(context.pendingToolPromises.values())
+      context.trace.endSpan(waitSpan)
+    }
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const undispatchedToolIds = continuation.pendingToolCallIds.filter((toolCallId) => {
+      const tool = context.toolCalls.get(toolCallId)
+      return (
+        !!tool &&
+        !tool.result &&
+        !tool.error &&
+        !context.pendingToolPromises.has(toolCallId) &&
+        tool.status !== 'executing'
+      )
+    })
+
+    if (undispatchedToolIds.length > 0) {
+      logger.warn('Checkpointed tools were never dispatched; executing before resume', {
+        checkpointId: continuation.checkpointId,
+        toolCallIds: undispatchedToolIds,
+      })
+      await Promise.allSettled(
+        undispatchedToolIds.map((toolCallId) =>
+          executeToolAndReport(toolCallId, context, execContext, options)
+        )
+      )
+    }
+
+    const results: Array<{
+      callId: string
+      name: string
+      data: unknown
+      success: boolean
+    }> = []
+    for (const toolCallId of continuation.pendingToolCallIds) {
+      const tool = context.toolCalls.get(toolCallId)
+      if (!tool || (!tool.result && !tool.error)) {
+        logger.error('Missing tool result for pending tool call', {
+          toolCallId,
+          checkpointId: continuation.checkpointId,
+          hasToolEntry: !!tool,
+          toolName: tool?.name,
+          toolStatus: tool?.status,
+          hasPendingPromise: context.pendingToolPromises.has(toolCallId),
+        })
+        throw new Error(`Cannot resume: missing result for pending tool call ${toolCallId}`)
+      }
+      results.push({
+        callId: toolCallId,
+        name: tool.name || '',
+        data: tool.result?.output ?? (tool.error ? { error: tool.error } : { error: 'unknown' }),
+        success: tool.result?.success ?? false,
+      })
+    }
+
+    logger.info('Resuming with tool results', {
+      checkpointId: continuation.checkpointId,
+      runId: continuation.runId,
+      toolCount: results.length,
+      pendingToolCallIds: continuation.pendingToolCallIds,
+      frameCount: continuation.frames?.length ?? 0,
+    })
+
+    context.awaitingAsyncContinuation = undefined
+    route = '/api/tools/resume'
+    payload = {
+      streamId: context.messageId,
+      checkpointId: continuation.checkpointId,
+      results,
+    }
+    logger.info('Prepared resume request payload', {
+      route,
+      streamId: context.messageId,
+      checkpointId: continuation.checkpointId,
+      resultCount: results.length,
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Execution context builder
+// ---------------------------------------------------------------------------
+
+async function buildExecutionContext(
+  requestPayload: Record<string, unknown>,
+  params: {
+    userId: string
+    workflowId?: string
+    workspaceId?: string
+    chatId?: string
+    executionId?: string
+    runId?: string
+    abortSignal?: AbortSignal
+  }
+): Promise<ExecutionContext> {
+  const { userId, workflowId, workspaceId, chatId, executionId, runId, abortSignal } = params
+  const userTimezone =
+    typeof requestPayload?.userTimezone === 'string' ? requestPayload.userTimezone : undefined
+
+  let execContext: ExecutionContext
+  if (workflowId) {
+    execContext = await prepareExecutionContext(userId, workflowId, chatId)
+  } else {
+    const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
+    execContext = {
+      userId,
+      workflowId: '',
+      workspaceId,
+      chatId,
+      decryptedEnvVars,
+    }
+  }
+
+  if (userTimezone) execContext.userTimezone = userTimezone
+  execContext.executionId = executionId
+  execContext.runId = runId
+  execContext.abortSignal = abortSignal
+  return execContext
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isAborted(options: CopilotLifecycleOptions, context: StreamingContext): boolean {
+  return !!(options.abortSignal?.aborted || context.wasAborted)
+}
+
+function cancelPendingTools(context: StreamingContext): void {
+  for (const [, toolCall] of context.toolCalls) {
+    if (toolCall.status === 'pending' || toolCall.status === 'executing') {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      toolCall.endTime = Date.now()
+      toolCall.error = 'Stopped by user'
+    }
+  }
+}
+
+function isRetryableStreamError(error: unknown): boolean {
+  if (error instanceof DOMException && error.name === 'AbortError') {
+    return false
+  }
+  if (error instanceof CopilotBackendError) {
+    return error.status !== undefined && error.status >= 500
+  }
+  if (error instanceof TypeError) {
+    return true
+  }
+  return false
+}
+
+function sleepWithAbort(ms: number, abortSignal?: AbortSignal): Promise<void> {
+  if (!abortSignal) {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+  if (abortSignal.aborted) {
+    return Promise.resolve()
+  }
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      abortSignal.removeEventListener('abort', onAbort)
+      resolve()
+    }, ms)
+    const onAbort = () => {
+      clearTimeout(timeoutId)
+      abortSignal.removeEventListener('abort', onAbort)
+      resolve()
+    }
+    abortSignal.addEventListener('abort', onAbort, { once: true })
+  })
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/start.test.ts b/apps/sim/lib/copilot/request/lifecycle/start.test.ts
new file mode 100644
index 00000000000..de610ca6ab4
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/start.test.ts
@@ -0,0 +1,179 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+
+const {
+  runCopilotLifecycle,
+  createRunSegment,
+  updateRunStatus,
+  resetBuffer,
+  allocateCursor,
+  appendEvent,
+  cleanupAbortMarker,
+  hasAbortMarker,
+  releasePendingChatStream,
+} = vi.hoisted(() => ({
+  runCopilotLifecycle: vi.fn(),
+  createRunSegment: vi.fn(),
+  updateRunStatus: vi.fn(),
+  resetBuffer: vi.fn(),
+  allocateCursor: vi.fn(),
+  appendEvent: vi.fn(),
+  cleanupAbortMarker: vi.fn(),
+  hasAbortMarker: vi.fn(),
+  releasePendingChatStream: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/lifecycle/continue', () => ({
+  runCopilotLifecycle,
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  createRunSegment,
+  updateRunStatus,
+}))
+
+let mockPublisherController: ReadableStreamDefaultController | null = null
+
+vi.mock('@/lib/copilot/request/session', () => ({
+  resetBuffer,
+  allocateCursor,
+  appendEvent,
+  cleanupAbortMarker,
+  hasAbortMarker,
+  releasePendingChatStream,
+  registerActiveStream: vi.fn(),
+  unregisterActiveStream: vi.fn(),
+  startAbortPoller: vi.fn().mockReturnValue(setInterval(() => {}, 999999)),
+  SSE_RESPONSE_HEADERS: {},
+  StreamWriter: vi.fn().mockImplementation(() => ({
+    attach: vi.fn().mockImplementation((ctrl: ReadableStreamDefaultController) => {
+      mockPublisherController = ctrl
+    }),
+    startKeepalive: vi.fn(),
+    stopKeepalive: vi.fn(),
+    flush: vi.fn(),
+    close: vi.fn().mockImplementation(() => {
+      try {
+        mockPublisherController?.close()
+      } catch {
+        // already closed
+      }
+    }),
+    markDisconnected: vi.fn(),
+    publish: vi.fn().mockImplementation(async (event: Record<string, unknown>) => {
+      appendEvent(event)
+    }),
+    get clientDisconnected() {
+      return false
+    },
+    get sawComplete() {
+      return false
+    },
+  })),
+}))
+vi.mock('@/lib/copilot/request/session/sse', () => ({
+  SSE_RESPONSE_HEADERS: {},
+}))
+
+vi.mock('@sim/db', () => ({
+  db: {
+    update: vi.fn(() => ({
+      set: vi.fn(() => ({
+        where: vi.fn(),
+      })),
+    })),
+  },
+}))
+
+vi.mock('@/lib/copilot/tasks', () => ({
+  taskPubSub: null,
+}))
+
+import { createSSEStream } from './start'
+
+async function drainStream(stream: ReadableStream) {
+  const reader = stream.getReader()
+  while (true) {
+    const { done } = await reader.read()
+    if (done) break
+  }
+}
+
+describe('createSSEStream terminal error handling', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetBuffer.mockResolvedValue(undefined)
+    allocateCursor
+      .mockResolvedValueOnce({ seq: 1, cursor: '1' })
+      .mockResolvedValueOnce({ seq: 2, cursor: '2' })
+      .mockResolvedValueOnce({ seq: 3, cursor: '3' })
+    appendEvent.mockImplementation(async (event: unknown) => event)
+    cleanupAbortMarker.mockResolvedValue(undefined)
+    hasAbortMarker.mockResolvedValue(false)
+    releasePendingChatStream.mockResolvedValue(undefined)
+    createRunSegment.mockResolvedValue(null)
+    updateRunStatus.mockResolvedValue(null)
+  })
+
+  it('writes a terminal error event before close when orchestration returns success=false', async () => {
+    runCopilotLifecycle.mockResolvedValue({
+      success: false,
+      error: 'resume failed',
+      content: '',
+      contentBlocks: [],
+      toolCalls: [],
+    })
+
+    const stream = createSSEStream({
+      requestPayload: { message: 'hello' },
+      userId: 'user-1',
+      streamId: 'stream-1',
+      executionId: 'exec-1',
+      runId: 'run-1',
+      currentChat: null,
+      isNewChat: false,
+      message: 'hello',
+      titleModel: 'gpt-5.4',
+      requestId: 'req-1',
+      orchestrateOptions: {},
+    })
+
+    await drainStream(stream)
+
+    expect(appendEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.error,
+      })
+    )
+  })
+
+  it('writes the thrown terminal error event before close for replay durability', async () => {
+    runCopilotLifecycle.mockRejectedValue(new Error('kaboom'))
+
+    const stream = createSSEStream({
+      requestPayload: { message: 'hello' },
+      userId: 'user-1',
+      streamId: 'stream-1',
+      executionId: 'exec-1',
+      runId: 'run-1',
+      currentChat: null,
+      isNewChat: false,
+      message: 'hello',
+      titleModel: 'gpt-5.4',
+      requestId: 'req-1',
+      orchestrateOptions: {},
+    })
+
+    await drainStream(stream)
+
+    expect(appendEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.error,
+      })
+    )
+  })
+})
diff --git a/apps/sim/lib/copilot/request/lifecycle/start.ts b/apps/sim/lib/copilot/request/lifecycle/start.ts
new file mode 100644
index 00000000000..7654d031125
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/start.ts
@@ -0,0 +1,310 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
+import { createRunSegment } from '@/lib/copilot/async-runs/repository'
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1SessionKind,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { RequestTraceV1Outcome } from '@/lib/copilot/generated/request-trace-v1'
+import { finalizeStream } from '@/lib/copilot/request/lifecycle/finalize'
+import type { CopilotLifecycleOptions } from '@/lib/copilot/request/lifecycle/run'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
+import {
+  cleanupAbortMarker,
+  registerActiveStream,
+  releasePendingChatStream,
+  resetBuffer,
+  StreamWriter,
+  startAbortPoller,
+  unregisterActiveStream,
+} from '@/lib/copilot/request/session'
+import { SSE_RESPONSE_HEADERS } from '@/lib/copilot/request/session/sse'
+import { reportTrace, TraceCollector } from '@/lib/copilot/request/trace'
+import { taskPubSub } from '@/lib/copilot/tasks'
+import { env } from '@/lib/core/config/env'
+
+export { SSE_RESPONSE_HEADERS }
+
+const logger = createLogger('CopilotChatStreaming')
+
+export interface StreamingOrchestrationParams {
+  requestPayload: Record<string, unknown>
+  userId: string
+  streamId: string
+  executionId: string
+  runId: string
+  chatId?: string
+  currentChat: any
+  isNewChat: boolean
+  message: string
+  titleModel: string
+  titleProvider?: string
+  requestId: string
+  workspaceId?: string
+  orchestrateOptions: Omit<CopilotLifecycleOptions, 'onEvent'>
+}
+
+export function createSSEStream(params: StreamingOrchestrationParams): ReadableStream {
+  const {
+    requestPayload,
+    userId,
+    streamId,
+    executionId,
+    runId,
+    chatId,
+    currentChat,
+    isNewChat,
+    message,
+    titleModel,
+    titleProvider,
+    requestId,
+    workspaceId,
+    orchestrateOptions,
+  } = params
+
+  const abortController = new AbortController()
+  registerActiveStream(streamId, abortController)
+
+  const publisher = new StreamWriter({ streamId, chatId, requestId })
+
+  const collector = new TraceCollector()
+
+  return new ReadableStream({
+    async start(controller) {
+      publisher.attach(controller)
+
+      const requestSpan = collector.startSpan('Mothership Request', 'request', {
+        streamId,
+        chatId,
+        runId,
+      })
+      let outcome: 'success' | 'error' | 'cancelled' = 'error'
+      let lifecycleResult:
+        | {
+            usage?: { prompt: number; completion: number }
+            cost?: { input: number; output: number; total: number }
+          }
+        | undefined
+
+      await resetBuffer(streamId)
+
+      if (chatId) {
+        createRunSegment({
+          id: runId,
+          executionId,
+          chatId,
+          userId,
+          workflowId: (requestPayload.workflowId as string | undefined) || null,
+          workspaceId,
+          streamId,
+          model: (requestPayload.model as string | undefined) || null,
+          provider: (requestPayload.provider as string | undefined) || null,
+          requestContext: { requestId },
+        }).catch((error) => {
+          logger.warn(`[${requestId}] Failed to create copilot run segment`, {
+            error: error instanceof Error ? error.message : String(error),
+          })
+        })
+      }
+
+      const abortPoller = startAbortPoller(streamId, abortController, { requestId })
+      publisher.startKeepalive()
+
+      if (chatId) {
+        publisher.publish({
+          type: MothershipStreamV1EventType.session,
+          payload: {
+            kind: MothershipStreamV1SessionKind.chat,
+            chatId,
+          },
+        })
+      }
+
+      fireTitleGeneration({
+        chatId,
+        currentChat,
+        isNewChat,
+        message,
+        titleModel,
+        titleProvider,
+        workspaceId,
+        requestId,
+        publisher,
+      })
+
+      try {
+        const result = await runCopilotLifecycle(requestPayload, {
+          ...orchestrateOptions,
+          executionId,
+          runId,
+          trace: collector,
+          simRequestId: requestId,
+          abortSignal: abortController.signal,
+          onEvent: async (event) => {
+            await publisher.publish(event)
+          },
+        })
+
+        lifecycleResult = result
+        outcome = abortController.signal.aborted
+          ? RequestTraceV1Outcome.cancelled
+          : result.success
+            ? RequestTraceV1Outcome.success
+            : RequestTraceV1Outcome.error
+        await finalizeStream(result, publisher, runId, abortController.signal.aborted, requestId)
+      } catch (error) {
+        outcome = abortController.signal.aborted
+          ? RequestTraceV1Outcome.cancelled
+          : RequestTraceV1Outcome.error
+        if (publisher.clientDisconnected) {
+          logger.info(`[${requestId}] Stream errored after client disconnect`, {
+            error: error instanceof Error ? error.message : 'Stream error',
+          })
+        }
+        logger.error(`[${requestId}] Unexpected orchestration error:`, error)
+
+        const syntheticResult = {
+          success: false as const,
+          content: '',
+          contentBlocks: [],
+          toolCalls: [],
+          error: 'An unexpected error occurred while processing the response.',
+        }
+        await finalizeStream(
+          syntheticResult,
+          publisher,
+          runId,
+          abortController.signal.aborted,
+          requestId
+        )
+      } finally {
+        collector.endSpan(
+          requestSpan,
+          outcome === RequestTraceV1Outcome.success
+            ? 'ok'
+            : outcome === RequestTraceV1Outcome.cancelled
+              ? 'cancelled'
+              : 'error'
+        )
+
+        clearInterval(abortPoller)
+        try {
+          await publisher.close()
+        } catch (error) {
+          logger.warn(`[${requestId}] Failed to flush stream persistence during close`, {
+            error: error instanceof Error ? error.message : String(error),
+          })
+        }
+        unregisterActiveStream(streamId)
+        if (chatId) {
+          await releasePendingChatStream(chatId, streamId)
+        }
+        await cleanupAbortMarker(streamId)
+
+        const trace = collector.build({
+          outcome: outcome as 'success' | 'error' | 'cancelled',
+          simRequestId: requestId,
+          streamId,
+          chatId,
+          runId,
+          executionId,
+          usage: lifecycleResult?.usage,
+          cost: lifecycleResult?.cost,
+        })
+        reportTrace(trace).catch(() => {})
+      }
+    },
+    cancel() {
+      publisher.markDisconnected()
+    },
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Title generation (fire-and-forget side effect)
+// ---------------------------------------------------------------------------
+
+function fireTitleGeneration(params: {
+  chatId?: string
+  currentChat: any
+  isNewChat: boolean
+  message: string
+  titleModel: string
+  titleProvider?: string
+  workspaceId?: string
+  requestId: string
+  publisher: StreamWriter
+}): void {
+  const {
+    chatId,
+    currentChat,
+    isNewChat,
+    message,
+    titleModel,
+    titleProvider,
+    workspaceId,
+    requestId,
+    publisher,
+  } = params
+  if (!chatId || currentChat?.title || !isNewChat) return
+
+  requestChatTitle({ message, model: titleModel, provider: titleProvider })
+    .then(async (title) => {
+      if (!title) return
+      await db.update(copilotChats).set({ title }).where(eq(copilotChats.id, chatId))
+      await publisher.publish({
+        type: MothershipStreamV1EventType.session,
+        payload: { kind: MothershipStreamV1SessionKind.title, title },
+      })
+      if (workspaceId) {
+        taskPubSub?.publishStatusChanged({ workspaceId, chatId, type: 'renamed' })
+      }
+    })
+    .catch((error) => {
+      logger.error(`[${requestId}] Title generation failed:`, error)
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Chat title helper
+// ---------------------------------------------------------------------------
+
+export async function requestChatTitle(params: {
+  message: string
+  model: string
+  provider?: string
+}): Promise<string | null> {
+  const { message, model, provider } = params
+  if (!message || !model) return null
+
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+  if (env.COPILOT_API_KEY) {
+    headers['x-api-key'] = env.COPILOT_API_KEY
+  }
+
+  try {
+    const response = await fetch(`${SIM_AGENT_API_URL}/api/generate-chat-title`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ message, model, ...(provider ? { provider } : {}) }),
+    })
+
+    const payload = await response.json().catch(() => ({}))
+    if (!response.ok) {
+      logger.warn('Failed to generate chat title via copilot backend', {
+        status: response.status,
+        error: payload,
+      })
+      return null
+    }
+
+    const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
+    return title || null
+  } catch (error) {
+    logger.error('Error generating chat title:', error)
+    return null
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/abort.ts b/apps/sim/lib/copilot/request/session/abort.ts
new file mode 100644
index 00000000000..3bf9cbd7bb4
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/abort.ts
@@ -0,0 +1,234 @@
+import { createLogger } from '@sim/logger'
+import { acquireLock, getRedisClient, releaseLock } from '@/lib/core/config/redis'
+import { clearAbortMarker, hasAbortMarker, writeAbortMarker } from './buffer'
+
+const logger = createLogger('SessionAbort')
+
+const activeStreams = new Map<string, AbortController>()
+const pendingChatStreams = new Map<
+  string,
+  { promise: Promise<void>; resolve: () => void; streamId: string }
+>()
+
+const DEFAULT_ABORT_POLL_MS = 1000
+const CHAT_STREAM_LOCK_TTL_SECONDS = 2 * 60 * 60
+
+function registerPendingChatStream(chatId: string, streamId: string): void {
+  let resolve!: () => void
+  const promise = new Promise<void>((r) => {
+    resolve = r
+  })
+  pendingChatStreams.set(chatId, { promise, resolve, streamId })
+}
+
+function resolvePendingChatStream(chatId: string, streamId: string): void {
+  const entry = pendingChatStreams.get(chatId)
+  if (entry && entry.streamId === streamId) {
+    entry.resolve()
+    pendingChatStreams.delete(chatId)
+  }
+}
+
+function getChatStreamLockKey(chatId: string): string {
+  return `copilot:chat-stream-lock:${chatId}`
+}
+
+export function registerActiveStream(streamId: string, controller: AbortController): void {
+  activeStreams.set(streamId, controller)
+}
+
+export function unregisterActiveStream(streamId: string): void {
+  activeStreams.delete(streamId)
+}
+
+export async function waitForPendingChatStream(
+  chatId: string,
+  timeoutMs = 5_000,
+  expectedStreamId?: string
+): Promise<boolean> {
+  const redis = getRedisClient()
+  const deadline = Date.now() + timeoutMs
+
+  for (;;) {
+    const entry = pendingChatStreams.get(chatId)
+    const localPending = !!entry && (!expectedStreamId || entry.streamId === expectedStreamId)
+
+    if (redis) {
+      try {
+        const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
+        const lockReleased =
+          !ownerStreamId || (expectedStreamId !== undefined && ownerStreamId !== expectedStreamId)
+        if (!localPending && lockReleased) {
+          return true
+        }
+      } catch (error) {
+        logger.warn('Failed to inspect chat stream lock while waiting', {
+          chatId,
+          expectedStreamId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    } else if (!localPending) {
+      return true
+    }
+
+    if (Date.now() >= deadline) {
+      return false
+    }
+    await new Promise((resolve) => setTimeout(resolve, 200))
+  }
+}
+
+export async function getPendingChatStreamId(chatId: string): Promise<string | null> {
+  const localEntry = pendingChatStreams.get(chatId)
+  if (localEntry?.streamId) {
+    return localEntry.streamId
+  }
+
+  const redis = getRedisClient()
+  if (!redis) {
+    return null
+  }
+
+  try {
+    return (await redis.get(getChatStreamLockKey(chatId))) || null
+  } catch (error) {
+    logger.warn('Failed to load chat stream lock owner', {
+      chatId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return null
+  }
+}
+
+export async function releasePendingChatStream(chatId: string, streamId: string): Promise<void> {
+  try {
+    await releaseLock(getChatStreamLockKey(chatId), streamId)
+  } catch (error) {
+    logger.warn('Failed to release chat stream lock', {
+      chatId,
+      streamId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  } finally {
+    resolvePendingChatStream(chatId, streamId)
+  }
+}
+
+export async function acquirePendingChatStream(
+  chatId: string,
+  streamId: string,
+  timeoutMs = 5_000
+): Promise<boolean> {
+  const redis = getRedisClient()
+  if (redis) {
+    const deadline = Date.now() + timeoutMs
+    for (;;) {
+      try {
+        const acquired = await acquireLock(
+          getChatStreamLockKey(chatId),
+          streamId,
+          CHAT_STREAM_LOCK_TTL_SECONDS
+        )
+        if (acquired) {
+          registerPendingChatStream(chatId, streamId)
+          return true
+        }
+        if (!pendingChatStreams.has(chatId)) {
+          const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
+          if (ownerStreamId) {
+            const settled = await waitForPendingChatStream(chatId, 0, ownerStreamId)
+            if (settled) {
+              continue
+            }
+          }
+        }
+      } catch (error) {
+        logger.warn('Failed to acquire chat stream lock', {
+          chatId,
+          streamId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+
+      if (Date.now() >= deadline) {
+        return false
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200))
+    }
+  }
+
+  for (;;) {
+    const existing = pendingChatStreams.get(chatId)
+    if (!existing) {
+      registerPendingChatStream(chatId, streamId)
+      return true
+    }
+
+    const settled = await Promise.race([
+      existing.promise.then(() => true),
+      new Promise<boolean>((resolve) => setTimeout(() => resolve(false), timeoutMs)),
+    ])
+    if (!settled) {
+      return false
+    }
+  }
+}
+
+/**
+ * Returns `true` if it aborted an in-process controller,
+ * `false` if it only wrote the marker (no local controller found).
+ */
+export async function abortActiveStream(streamId: string): Promise<boolean> {
+  await writeAbortMarker(streamId)
+  const controller = activeStreams.get(streamId)
+  if (!controller) return false
+  controller.abort()
+  activeStreams.delete(streamId)
+  return true
+}
+
+const pollingStreams = new Set<string>()
+
+export function startAbortPoller(
+  streamId: string,
+  abortController: AbortController,
+  options?: { pollMs?: number; requestId?: string }
+): ReturnType<typeof setInterval> {
+  const pollMs = options?.pollMs ?? DEFAULT_ABORT_POLL_MS
+  const requestId = options?.requestId
+
+  return setInterval(() => {
+    if (pollingStreams.has(streamId)) return
+    pollingStreams.add(streamId)
+
+    void (async () => {
+      try {
+        const shouldAbort = await hasAbortMarker(streamId)
+        if (shouldAbort && !abortController.signal.aborted) {
+          abortController.abort()
+          await clearAbortMarker(streamId)
+        }
+      } catch (error) {
+        logger.warn('Failed to poll stream abort marker', {
+          streamId,
+          ...(requestId ? { requestId } : {}),
+          error: error instanceof Error ? error.message : String(error),
+        })
+      } finally {
+        pollingStreams.delete(streamId)
+      }
+    })()
+  }, pollMs)
+}
+
+export async function cleanupAbortMarker(streamId: string): Promise<void> {
+  try {
+    await clearAbortMarker(streamId)
+  } catch (error) {
+    logger.warn('Failed to clear stream abort marker during cleanup', {
+      streamId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/buffer.test.ts b/apps/sim/lib/copilot/request/session/buffer.test.ts
new file mode 100644
index 00000000000..9ce631bd16f
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/buffer.test.ts
@@ -0,0 +1,148 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { createEvent } from '@/lib/copilot/request/session/event'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+type StoredEnvelope = {
+  score: number
+  value: string
+}
+
+const createRedisStub = () => {
+  const counters = new Map<string, number>()
+  const values = new Map<string, string>()
+  const sortedSets = new Map<string, StoredEnvelope[]>()
+
+  const api = {
+    incr: vi.fn().mockImplementation((key: string) => {
+      const next = (counters.get(key) ?? 0) + 1
+      counters.set(key, next)
+      return next
+    }),
+    expire: vi.fn().mockResolvedValue(1),
+    del: vi.fn().mockImplementation((...keys: string[]) => {
+      for (const key of keys) {
+        values.delete(key)
+        sortedSets.delete(key)
+        counters.delete(key)
+      }
+      return Promise.resolve(keys.length)
+    }),
+    zadd: vi.fn().mockImplementation((key: string, score: number, value: string) => {
+      const entries = sortedSets.get(key) ?? []
+      entries.push({ score, value })
+      sortedSets.set(key, entries)
+      return Promise.resolve(1)
+    }),
+    zremrangebyrank: vi.fn().mockImplementation((key: string, start: number, stop: number) => {
+      const entries = [...(sortedSets.get(key) ?? [])].sort((a, b) => a.score - b.score)
+      const normalizedStart = start < 0 ? Math.max(entries.length + start, 0) : start
+      const normalizedStop = stop < 0 ? entries.length + stop : stop
+      const next = entries.filter(
+        (_entry, index) => index < normalizedStart || index > normalizedStop
+      )
+      sortedSets.set(key, next)
+      return Promise.resolve(1)
+    }),
+    zrangebyscore: vi.fn().mockImplementation((key: string, min: number, max: string) => {
+      const upperBound = max === '+inf' ? Number.POSITIVE_INFINITY : Number(max)
+      const entries = [...(sortedSets.get(key) ?? [])]
+        .filter((entry) => entry.score >= min && entry.score <= upperBound)
+        .sort((a, b) => a.score - b.score)
+        .map((entry) => entry.value)
+      return Promise.resolve(entries)
+    }),
+    set: vi.fn().mockImplementation((key: string, value: string) => {
+      values.set(key, value)
+      return Promise.resolve('OK')
+    }),
+    get: vi.fn().mockImplementation((key: string) => Promise.resolve(values.get(key) ?? null)),
+    pipeline: vi.fn().mockImplementation(() => {
+      const operations: Array<() => Promise<unknown>> = []
+      const pipeline = {
+        zadd: (...args: [string, number, string]) => {
+          operations.push(() => api.zadd(...args))
+          return pipeline
+        },
+        expire: (...args: [string, number]) => {
+          operations.push(() => api.expire(...args))
+          return pipeline
+        },
+        set: (...args: [string, string, 'EX', number]) => {
+          operations.push(() => api.set(args[0], args[1]))
+          return pipeline
+        },
+        zremrangebyrank: (...args: [string, number, number]) => {
+          operations.push(() => api.zremrangebyrank(...args))
+          return pipeline
+        },
+        exec: vi.fn().mockImplementation(async () => {
+          const results: Array<[null, unknown]> = []
+          for (const operation of operations) {
+            results.push([null, await operation()])
+          }
+          return results
+        }),
+      }
+      return pipeline
+    }),
+  }
+
+  return api
+}
+
+let mockRedis: ReturnType<typeof createRedisStub>
+
+vi.mock('@/lib/core/config/redis', () => ({
+  getRedisClient: () => mockRedis,
+}))
+
+import { allocateCursor, appendEvent, readEvents } from '@/lib/copilot/request/session/buffer'
+
+describe('mothership-stream-outbox', () => {
+  beforeEach(() => {
+    mockRedis = createRedisStub()
+    vi.clearAllMocks()
+  })
+
+  it.concurrent('replays envelopes after a given cursor', async () => {
+    const firstCursor = await allocateCursor('stream-1')
+    const secondCursor = await allocateCursor('stream-1')
+
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: firstCursor.cursor,
+        seq: firstCursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+      })
+    )
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: secondCursor.cursor,
+        seq: secondCursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'world' },
+      })
+    )
+
+    const allEvents = await readEvents('stream-1', '0')
+    expect(allEvents.map((entry) => entry.payload.text)).toEqual(['hello', 'world'])
+
+    const replayed = await readEvents('stream-1', '1')
+    expect(replayed.map((entry) => entry.payload.text)).toEqual(['world'])
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/buffer.ts b/apps/sim/lib/copilot/request/session/buffer.ts
new file mode 100644
index 00000000000..89e661366ce
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/buffer.ts
@@ -0,0 +1,230 @@
+import { createLogger } from '@sim/logger'
+import type { MothershipStreamV1EventEnvelope } from '@/lib/copilot/generated/mothership-stream-v1'
+import { env } from '@/lib/core/config/env'
+import { getRedisClient } from '@/lib/core/config/redis'
+
+const logger = createLogger('SessionBuffer')
+
+const STREAM_OUTBOX_PREFIX = 'mothership_stream:'
+const DEFAULT_TTL_SECONDS = 60 * 60
+const DEFAULT_EVENT_LIMIT = 5_000
+const RETRY_DELAYS_MS = [0, 50, 150] as const
+
+type RedisOperationMetadata = {
+  operation: string
+  streamId: string
+}
+
+function getEventsKey(streamId: string) {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:events`
+}
+
+function getSeqKey(streamId: string) {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:seq`
+}
+
+function getAbortKey(streamId: string) {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:abort`
+}
+
+export type StreamConfig = {
+  ttlSeconds: number
+  eventLimit: number
+}
+
+export function getStreamConfig(): StreamConfig {
+  return {
+    ttlSeconds: parsePositiveNumber(env.COPILOT_STREAM_TTL_SECONDS, DEFAULT_TTL_SECONDS),
+    eventLimit: parsePositiveNumber(env.COPILOT_STREAM_EVENT_LIMIT, DEFAULT_EVENT_LIMIT),
+  }
+}
+
+function parsePositiveNumber(value: number | string | undefined, fallback: number) {
+  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+    return value
+  }
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
+}
+
+async function withRedisRetry<T>(
+  metadata: RedisOperationMetadata,
+  operation: (redis: NonNullable<ReturnType<typeof getRedisClient>>) => Promise<T>
+): Promise<T> {
+  const redis = getRedisClient()
+  if (!redis) {
+    throw new Error('Redis is required for mothership stream durability')
+  }
+
+  let lastError: unknown
+
+  for (let attempt = 0; attempt < RETRY_DELAYS_MS.length; attempt++) {
+    const delay = RETRY_DELAYS_MS[attempt]
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    }
+
+    try {
+      return await operation(redis)
+    } catch (error) {
+      lastError = error
+      logger.warn('Redis stream operation failed', {
+        operation: metadata.operation,
+        streamId: metadata.streamId,
+        attempt: attempt + 1,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  throw lastError instanceof Error
+    ? lastError
+    : new Error(`${metadata.operation} failed for stream ${metadata.streamId}`)
+}
+
+export async function allocateCursor(streamId: string): Promise<{
+  seq: number
+  cursor: string
+}> {
+  const config = getStreamConfig()
+  const seq = await withRedisRetry({ operation: 'allocate_cursor', streamId }, async (redis) => {
+    const nextValue = await redis.incr(getSeqKey(streamId))
+    await redis.expire(getSeqKey(streamId), config.ttlSeconds)
+    return typeof nextValue === 'number' ? nextValue : Number(nextValue)
+  })
+
+  return { seq, cursor: String(seq) }
+}
+
+export async function resetBuffer(streamId: string): Promise<void> {
+  await withRedisRetry({ operation: 'reset_outbox', streamId }, async (redis) => {
+    await redis.del(getEventsKey(streamId), getSeqKey(streamId), getAbortKey(streamId))
+  })
+}
+
+export async function appendEvents(
+  envelopes: MothershipStreamV1EventEnvelope[]
+): Promise<MothershipStreamV1EventEnvelope[]> {
+  if (envelopes.length === 0) {
+    return envelopes
+  }
+
+  const streamId = envelopes[0].stream.streamId
+  const config = getStreamConfig()
+
+  await withRedisRetry({ operation: 'append_event', streamId }, async (redis) => {
+    const key = getEventsKey(streamId)
+    const seqKey = getSeqKey(streamId)
+    const pipeline = redis.pipeline()
+    const zaddArgs: Array<number | string> = []
+    for (const envelope of envelopes) {
+      zaddArgs.push(envelope.seq, JSON.stringify(envelope))
+    }
+    pipeline.zadd(key, ...(zaddArgs as [number, string, ...Array<number | string>]))
+    pipeline.expire(key, config.ttlSeconds)
+    pipeline.set(seqKey, String(envelopes[envelopes.length - 1].seq), 'EX', config.ttlSeconds)
+    if (config.eventLimit > 0) {
+      pipeline.zremrangebyrank(key, 0, -config.eventLimit - 1)
+    }
+    await pipeline.exec()
+  })
+
+  return envelopes
+}
+
+export async function appendEvent(
+  envelope: MothershipStreamV1EventEnvelope
+): Promise<MothershipStreamV1EventEnvelope> {
+  await appendEvents([envelope])
+  return envelope
+}
+
+export class InvalidCursorError extends Error {
+  constructor(
+    public readonly streamId: string,
+    public readonly cursor: string
+  ) {
+    super(`Invalid non-numeric cursor "${cursor}" for stream ${streamId}`)
+    this.name = 'InvalidCursorError'
+  }
+}
+
+export async function readEvents(
+  streamId: string,
+  afterCursor: string
+): Promise<MothershipStreamV1EventEnvelope[]> {
+  const afterSeq = Number(afterCursor || '0')
+  if (!Number.isFinite(afterSeq)) {
+    throw new InvalidCursorError(streamId, afterCursor)
+  }
+  const minScore = afterSeq + 1
+
+  const rawEntries = await withRedisRetry({ operation: 'read_events', streamId }, async (redis) => {
+    return redis.zrangebyscore(getEventsKey(streamId), minScore, '+inf')
+  })
+
+  const envelopes: MothershipStreamV1EventEnvelope[] = []
+  for (const entry of rawEntries) {
+    try {
+      const parsed = JSON.parse(entry) as MothershipStreamV1EventEnvelope
+      if (!parsed?.stream?.streamId || typeof parsed.seq !== 'number') {
+        logger.warn('Skipping corrupt outbox entry: missing required fields', { streamId })
+        continue
+      }
+      envelopes.push(parsed)
+    } catch (error) {
+      logger.warn('Skipping corrupt outbox entry: JSON parse failed', {
+        streamId,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+  return envelopes
+}
+
+export async function getOldestSeq(streamId: string): Promise<number | null> {
+  return withRedisRetry({ operation: 'get_oldest_seq', streamId }, async (redis) => {
+    const entries = await redis.zrangebyscore(getEventsKey(streamId), '-inf', '+inf', 'LIMIT', 0, 1)
+    if (!entries || entries.length === 0) {
+      return null
+    }
+    try {
+      const parsed = JSON.parse(entries[0]) as { seq?: number }
+      return typeof parsed.seq === 'number' ? parsed.seq : null
+    } catch {
+      logger.warn('Failed to parse oldest outbox entry', { streamId })
+      return null
+    }
+  })
+}
+
+export async function getLatestSeq(streamId: string): Promise<number | null> {
+  return withRedisRetry({ operation: 'get_latest_seq', streamId }, async (redis) => {
+    const currentSeq = await redis.get(getSeqKey(streamId))
+    if (currentSeq === null) {
+      return null
+    }
+    const parsed = Number(currentSeq)
+    return Number.isFinite(parsed) ? parsed : null
+  })
+}
+
+export async function writeAbortMarker(streamId: string): Promise<void> {
+  const ttlSeconds = getStreamConfig().ttlSeconds
+  await withRedisRetry({ operation: 'write_abort_marker', streamId }, async (redis) => {
+    await redis.set(getAbortKey(streamId), '1', 'EX', ttlSeconds)
+  })
+}
+
+export async function hasAbortMarker(streamId: string): Promise<boolean> {
+  return withRedisRetry({ operation: 'read_abort_marker', streamId }, async (redis) => {
+    const marker = await redis.get(getAbortKey(streamId))
+    return marker === '1'
+  })
+}
+
+export async function clearAbortMarker(streamId: string): Promise<void> {
+  await withRedisRetry({ operation: 'clear_abort_marker', streamId }, async (redis) => {
+    await redis.del(getAbortKey(streamId))
+  })
+}
diff --git a/apps/sim/lib/copilot/request/session/event.ts b/apps/sim/lib/copilot/request/session/event.ts
new file mode 100644
index 00000000000..adfc00dc5dd
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/event.ts
@@ -0,0 +1,85 @@
+import { createLogger } from '@sim/logger'
+import type {
+  MothershipStreamV1EventEnvelope,
+  MothershipStreamV1EventType as MothershipStreamV1EventTypeUnion,
+  MothershipStreamV1StreamScope,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent } from './types'
+
+const logger = createLogger('SessionEvent')
+
+type JsonRecord = Record<string, unknown>
+
+const VALID_EVENT_TYPES = new Set<string>(Object.values(MothershipStreamV1EventType))
+
+export const TOOL_CALL_STATUS = {
+  generating: 'generating',
+} as const
+
+export function createEvent(input: {
+  streamId: string
+  chatId?: string
+  cursor: string
+  seq: number
+  requestId: string
+  type: MothershipStreamV1EventTypeUnion
+  payload: JsonRecord
+  scope?: MothershipStreamV1StreamScope
+  ts?: string
+}): MothershipStreamV1EventEnvelope {
+  const { streamId, chatId, cursor, seq, requestId, type, payload, scope, ts } = input
+
+  return {
+    v: 1,
+    type,
+    seq,
+    ts: ts ?? new Date().toISOString(),
+    stream: {
+      streamId,
+      ...(chatId ? { chatId } : {}),
+      cursor,
+    },
+    trace: {
+      requestId,
+    },
+    ...(scope ? { scope } : {}),
+    payload,
+  }
+}
+
+export function isEventRecord(value: unknown): value is MothershipStreamV1EventEnvelope {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const record = value as Record<string, unknown>
+  return (
+    record.v === 1 &&
+    typeof record.type === 'string' &&
+    VALID_EVENT_TYPES.has(record.type) &&
+    typeof record.seq === 'number' &&
+    typeof record.ts === 'string' &&
+    !!record.stream &&
+    typeof record.stream === 'object' &&
+    typeof (record.stream as Record<string, unknown>).streamId === 'string' &&
+    !!record.payload &&
+    typeof record.payload === 'object'
+  )
+}
+
+export function eventToStreamEvent(envelope: MothershipStreamV1EventEnvelope): StreamEvent {
+  return {
+    type: envelope.type,
+    payload: asJsonRecord(envelope.payload),
+    ...(envelope.scope ? { scope: envelope.scope } : {}),
+  }
+}
+
+function asJsonRecord(value: unknown): JsonRecord {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as JsonRecord
+  }
+  logger.warn('Envelope payload is not a valid JSON record, defaulting to empty object')
+  return {}
+}
diff --git a/apps/sim/lib/copilot/request/session/index.ts b/apps/sim/lib/copilot/request/session/index.ts
new file mode 100644
index 00000000000..6a6eddd1ee7
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/index.ts
@@ -0,0 +1,29 @@
+export {
+  abortActiveStream,
+  acquirePendingChatStream,
+  cleanupAbortMarker,
+  getPendingChatStreamId,
+  registerActiveStream,
+  releasePendingChatStream,
+  startAbortPoller,
+  unregisterActiveStream,
+  waitForPendingChatStream,
+} from './abort'
+export {
+  allocateCursor,
+  appendEvent,
+  appendEvents,
+  clearAbortMarker,
+  getLatestSeq,
+  getOldestSeq,
+  hasAbortMarker,
+  InvalidCursorError,
+  readEvents,
+  resetBuffer,
+  writeAbortMarker,
+} from './buffer'
+export { createEvent, eventToStreamEvent, isEventRecord, TOOL_CALL_STATUS } from './event'
+export { checkForReplayGap, type ReplayGapResult } from './recovery'
+export { encodeSSEComment, encodeSSEEnvelope, SSE_RESPONSE_HEADERS } from './sse'
+export type { StreamEvent } from './types'
+export { StreamWriter, type StreamWriterOptions } from './writer'
diff --git a/apps/sim/lib/copilot/request/session/recovery.ts b/apps/sim/lib/copilot/request/session/recovery.ts
new file mode 100644
index 00000000000..38afa6ad377
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/recovery.ts
@@ -0,0 +1,74 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { getLatestSeq, getOldestSeq } from './buffer'
+import { createEvent } from './event'
+
+const logger = createLogger('SessionRecovery')
+
+export interface ReplayGapResult {
+  gapDetected: true
+  envelopes: ReturnType<typeof createEvent>[]
+}
+
+export async function checkForReplayGap(
+  streamId: string,
+  afterCursor: string
+): Promise<ReplayGapResult | null> {
+  const requestedAfterSeq = Number(afterCursor || '0')
+  if (requestedAfterSeq <= 0) {
+    return null
+  }
+
+  const oldestSeq = await getOldestSeq(streamId)
+  const latestSeq = await getLatestSeq(streamId)
+
+  if (
+    latestSeq !== null &&
+    latestSeq > 0 &&
+    oldestSeq !== null &&
+    requestedAfterSeq < oldestSeq - 1
+  ) {
+    logger.warn('Replay gap detected: requested cursor is below oldest available event', {
+      streamId,
+      requestedAfterSeq,
+      oldestAvailableSeq: oldestSeq,
+      latestSeq,
+    })
+
+    const gapEnvelope = createEvent({
+      streamId,
+      cursor: String(latestSeq + 1),
+      seq: latestSeq + 1,
+      requestId: '',
+      type: MothershipStreamV1EventType.error,
+      payload: {
+        message: 'Replay history is no longer available. Some events may have been lost.',
+        code: 'replay_gap',
+        oldestAvailableSeq: oldestSeq,
+        requestedAfterSeq,
+      },
+    })
+
+    const terminalEnvelope = createEvent({
+      streamId,
+      cursor: String(latestSeq + 2),
+      seq: latestSeq + 2,
+      requestId: '',
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: MothershipStreamV1CompletionStatus.error,
+        reason: 'replay_gap',
+      },
+    })
+
+    return {
+      gapDetected: true,
+      envelopes: [gapEnvelope, terminalEnvelope],
+    }
+  }
+
+  return null
+}
diff --git a/apps/sim/lib/copilot/request/session/sse.ts b/apps/sim/lib/copilot/request/session/sse.ts
new file mode 100644
index 00000000000..74b11454047
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/sse.ts
@@ -0,0 +1,16 @@
+import { SSE_HEADERS } from '@/lib/core/utils/sse'
+
+const encoder = new TextEncoder()
+
+export function encodeSSEEnvelope(envelope: unknown): Uint8Array {
+  return encoder.encode(`data: ${JSON.stringify(envelope)}\n\n`)
+}
+
+export function encodeSSEComment(comment: string): Uint8Array {
+  return encoder.encode(`: ${comment}\n\n`)
+}
+
+export const SSE_RESPONSE_HEADERS = {
+  ...SSE_HEADERS,
+  'Content-Encoding': 'none',
+} as const
diff --git a/apps/sim/lib/copilot/request/session/types.ts b/apps/sim/lib/copilot/request/session/types.ts
new file mode 100644
index 00000000000..1cd8b7af5f3
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/types.ts
@@ -0,0 +1,10 @@
+import type {
+  MothershipStreamV1EventType,
+  MothershipStreamV1StreamScope,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+
+export interface StreamEvent {
+  type: MothershipStreamV1EventType
+  payload: Record<string, unknown>
+  scope?: MothershipStreamV1StreamScope
+}
diff --git a/apps/sim/lib/copilot/request/session/writer.test.ts b/apps/sim/lib/copilot/request/session/writer.test.ts
new file mode 100644
index 00000000000..b125cac82b3
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/writer.test.ts
@@ -0,0 +1,149 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+
+const { appendEvents } = vi.hoisted(() => ({
+  appendEvents: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/session/buffer', () => ({
+  appendEvents,
+}))
+
+import { StreamWriter } from '@/lib/copilot/request/session/writer'
+
+function decodeChunk(value: Uint8Array): string {
+  return new TextDecoder().decode(value)
+}
+
+describe('StreamWriter', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useRealTimers()
+  })
+
+  it('enqueues before persistence completes and flushes pending writes on close', async () => {
+    let releasePersist: (() => void) | null = null
+    appendEvents.mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          releasePersist = resolve
+        })
+    )
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      chatId: 'chat-1',
+      requestId: 'req-1',
+    })
+
+    const chunks: string[] = []
+    let closeCount = 0
+    const controller = {
+      enqueue: vi.fn((value: Uint8Array) => {
+        chunks.push(decodeChunk(value))
+      }),
+      close: vi.fn(() => {
+        closeCount += 1
+      }),
+    } as unknown as ReadableStreamDefaultController
+
+    writer.attach(controller)
+    await writer.publish({
+      type: MothershipStreamV1EventType.text,
+      payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+    })
+
+    expect(controller.enqueue).toHaveBeenCalledOnce()
+    expect(appendEvents).not.toHaveBeenCalled()
+    expect(chunks[0]).toContain('"text":"hello"')
+    expect(closeCount).toBe(0)
+
+    const closePromise = writer.close()
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(appendEvents).toHaveBeenCalledOnce()
+    expect(closeCount).toBe(0)
+
+    const resolvePersist = releasePersist
+    if (typeof resolvePersist === 'function') {
+      resolvePersist()
+    }
+    await closePromise
+
+    expect(closeCount).toBe(1)
+  })
+
+  it('batches publishes on the flush timer and preserves sequence order', async () => {
+    vi.useFakeTimers()
+    const persistedSeqs: number[] = []
+    appendEvents.mockImplementation(async (envelopes) => {
+      persistedSeqs.push(...envelopes.map((envelope) => envelope.seq))
+      return envelopes
+    })
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      requestId: 'req-1',
+    })
+
+    const chunks: string[] = []
+    const controller = {
+      enqueue: vi.fn((value: Uint8Array) => {
+        chunks.push(decodeChunk(value))
+      }),
+      close: vi.fn(),
+    } as unknown as ReadableStreamDefaultController
+
+    writer.attach(controller)
+    await Promise.all([
+      writer.publish({
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'one' },
+      }),
+      writer.publish({
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'two' },
+      }),
+    ])
+    expect(appendEvents).not.toHaveBeenCalled()
+
+    await vi.advanceTimersByTimeAsync(15)
+    await writer.close()
+
+    expect(persistedSeqs).toEqual([1, 2])
+    expect(appendEvents).toHaveBeenCalledWith([
+      expect.objectContaining({ seq: 1 }),
+      expect.objectContaining({ seq: 2 }),
+    ])
+    expect(chunks[0]).toContain('"seq":1')
+    expect(chunks[1]).toContain('"seq":2')
+  })
+
+  it('flush waits for persistence and surfaces failures', async () => {
+    appendEvents.mockRejectedValueOnce(new Error('redis down'))
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      requestId: 'req-1',
+    })
+
+    writer.attach({
+      enqueue: vi.fn(),
+      close: vi.fn(),
+    } as unknown as ReadableStreamDefaultController)
+
+    await writer.publish({
+      type: MothershipStreamV1EventType.text,
+      payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'boom' },
+    })
+
+    await expect(writer.flush()).rejects.toThrow('redis down')
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/writer.ts b/apps/sim/lib/copilot/request/session/writer.ts
new file mode 100644
index 00000000000..5e330ccbf16
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/writer.ts
@@ -0,0 +1,197 @@
+import { createLogger } from '@sim/logger'
+import type { MothershipStreamV1EventEnvelope } from '@/lib/copilot/generated/mothership-stream-v1'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import { appendEvents } from './buffer'
+import { createEvent } from './event'
+import { encodeSSEComment, encodeSSEEnvelope } from './sse'
+import type { StreamEvent } from './types'
+
+const logger = createLogger('StreamWriter')
+
+const DEFAULT_KEEPALIVE_MS = 15_000
+const DEFAULT_PERSIST_FLUSH_INTERVAL_MS = 15
+const DEFAULT_PERSIST_FLUSH_MAX_BATCH = 200
+
+export interface StreamWriterOptions {
+  streamId: string
+  chatId?: string
+  requestId: string
+  keepaliveMs?: number
+}
+
+export class StreamWriter {
+  private readonly streamId: string
+  private readonly chatId: string | undefined
+  private readonly requestId: string
+  private readonly keepaliveMs: number
+  private readonly flushIntervalMs: number
+  private readonly flushMaxBatch: number
+  private readonly encoder: TextEncoder
+  private controller: ReadableStreamDefaultController | null = null
+  private keepaliveInterval: ReturnType<typeof setInterval> | null = null
+  private flushTimer: ReturnType<typeof setTimeout> | null = null
+  private _clientDisconnected = false
+  private _sawComplete = false
+  private nextSeq = 0
+  private pendingEnvelopes: MothershipStreamV1EventEnvelope[] = []
+  private persistenceTail: Promise<void> = Promise.resolve()
+  private lastPersistenceError: Error | null = null
+
+  constructor(options: StreamWriterOptions) {
+    this.streamId = options.streamId
+    this.chatId = options.chatId
+    this.requestId = options.requestId
+    this.keepaliveMs = options.keepaliveMs ?? DEFAULT_KEEPALIVE_MS
+    this.flushIntervalMs = DEFAULT_PERSIST_FLUSH_INTERVAL_MS
+    this.flushMaxBatch = DEFAULT_PERSIST_FLUSH_MAX_BATCH
+    this.encoder = new TextEncoder()
+  }
+
+  get clientDisconnected(): boolean {
+    return this._clientDisconnected
+  }
+
+  get sawComplete(): boolean {
+    return this._sawComplete
+  }
+
+  attach(controller: ReadableStreamDefaultController): void {
+    this.controller = controller
+  }
+
+  startKeepalive(): void {
+    this.keepaliveInterval = setInterval(() => {
+      if (this._clientDisconnected || !this.controller) return
+      try {
+        this.controller.enqueue(encodeSSEComment('keepalive'))
+      } catch (error) {
+        this._clientDisconnected = true
+        logger.warn('Keepalive enqueue failed, marking client disconnected', {
+          streamId: this.streamId,
+          requestId: this.requestId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }, this.keepaliveMs)
+  }
+
+  stopKeepalive(): void {
+    if (this.keepaliveInterval) {
+      clearInterval(this.keepaliveInterval)
+      this.keepaliveInterval = null
+    }
+  }
+
+  publish(event: StreamEvent): void {
+    const envelope = this.createEnvelope(event)
+    this.enqueue(envelope)
+    this.queuePersistence(envelope)
+    if (event.type === MothershipStreamV1EventType.complete) {
+      this._sawComplete = true
+    }
+  }
+
+  markDisconnected(): void {
+    this._clientDisconnected = true
+  }
+
+  async flush(): Promise<void> {
+    this.flushPendingPersistence()
+    await this.persistenceTail
+    if (this.lastPersistenceError) {
+      const error = this.lastPersistenceError
+      this.lastPersistenceError = null
+      throw error
+    }
+  }
+
+  async close(): Promise<void> {
+    this.stopKeepalive()
+    this.clearFlushTimer()
+    await this.flush()
+    if (!this.controller) return
+    try {
+      this.controller.close()
+    } catch {
+      // Controller already closed
+    }
+    this.controller = null
+  }
+
+  private enqueue(envelope: MothershipStreamV1EventEnvelope): void {
+    if (this._clientDisconnected || !this.controller) return
+    try {
+      this.controller.enqueue(encodeSSEEnvelope(envelope))
+    } catch (error) {
+      this._clientDisconnected = true
+      logger.warn('Envelope enqueue failed, marking client disconnected', {
+        streamId: this.streamId,
+        requestId: this.requestId,
+        seq: envelope.seq,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  private createEnvelope(event: StreamEvent): MothershipStreamV1EventEnvelope {
+    const seq = ++this.nextSeq
+    return createEvent({
+      streamId: this.streamId,
+      chatId: this.chatId,
+      cursor: String(seq),
+      seq,
+      requestId: this.requestId,
+      type: event.type,
+      payload: event.payload,
+      scope: event.scope,
+    })
+  }
+
+  private queuePersistence(envelope: MothershipStreamV1EventEnvelope): void {
+    this.pendingEnvelopes.push(envelope)
+    if (this.pendingEnvelopes.length >= this.flushMaxBatch) {
+      this.flushPendingPersistence()
+      return
+    }
+    if (this.flushTimer || this.pendingEnvelopes.length === 0) {
+      return
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null
+      this.flushPendingPersistence()
+    }, this.flushIntervalMs)
+  }
+
+  private flushPendingPersistence(): void {
+    this.clearFlushTimer()
+    if (this.pendingEnvelopes.length === 0) {
+      return
+    }
+    const batch = this.pendingEnvelopes
+    this.pendingEnvelopes = []
+    this.persistenceTail = this.persistenceTail
+      .catch(() => undefined)
+      .then(() => appendEvents(batch))
+      .then(() => {
+        this.lastPersistenceError = null
+      })
+      .catch((error) => {
+        this.lastPersistenceError = error instanceof Error ? error : new Error(String(error))
+        logger.warn('Failed to persist stream envelope batch', {
+          streamId: this.streamId,
+          requestId: this.requestId,
+          batchSize: batch.length,
+          firstSeq: batch[0]?.seq,
+          lastSeq: batch[batch.length - 1]?.seq,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      })
+  }
+
+  private clearFlushTimer(): void {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer)
+      this.flushTimer = null
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/sse-utils.ts b/apps/sim/lib/copilot/request/sse-utils.ts
new file mode 100644
index 00000000000..f5e68db0dd7
--- /dev/null
+++ b/apps/sim/lib/copilot/request/sse-utils.ts
@@ -0,0 +1,80 @@
+import { STREAM_BUFFER_MAX_DEDUP_ENTRIES } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { TOOL_CALL_STATUS } from '@/lib/copilot/request/session/event'
+import type { StreamEvent } from '@/lib/copilot/request/types'
+
+type EventDataObject = Record<string, unknown> | undefined
+
+/** Safely cast event.data to a record for property access. */
+export const asRecord = (data: unknown): Record<string, unknown> =>
+  (data && typeof data === 'object' && !Array.isArray(data) ? data : {}) as Record<string, unknown>
+
+/**
+ * In-memory tool event dedupe with bounded size.
+ *
+ * NOTE: Process-local only. In a multi-instance setup (e.g., ECS),
+ * each task maintains its own dedupe cache.
+ */
+const seenToolCalls = new Set<string>()
+const seenToolResults = new Set<string>()
+
+function addToSet(set: Set<string>, id: string): void {
+  if (set.size >= STREAM_BUFFER_MAX_DEDUP_ENTRIES) {
+    const first = set.values().next().value
+    if (first) set.delete(first)
+  }
+  set.add(id)
+}
+
+export const getEventData = (event: StreamEvent): EventDataObject => {
+  if (!event.payload || typeof event.payload !== 'object' || Array.isArray(event.payload)) {
+    return undefined
+  }
+  return event.payload
+}
+
+function getToolCallIdFromEvent(event: StreamEvent): string | undefined {
+  const data = getEventData(event)
+  return (data?.toolCallId as string | undefined) || (data?.id as string | undefined)
+}
+
+function markToolCallSeen(toolCallId: string): void {
+  addToSet(seenToolCalls, toolCallId)
+}
+
+function wasToolCallSeen(toolCallId: string): boolean {
+  return seenToolCalls.has(toolCallId)
+}
+
+export function markToolResultSeen(toolCallId: string): void {
+  addToSet(seenToolResults, toolCallId)
+}
+
+export function wasToolResultSeen(toolCallId: string): boolean {
+  return seenToolResults.has(toolCallId)
+}
+
+export function shouldSkipToolCallEvent(event: StreamEvent): boolean {
+  if (event.type !== MothershipStreamV1EventType.tool) return false
+  const eventData = getEventData(event)
+  if (eventData?.phase !== MothershipStreamV1ToolPhase.call) return false
+  if (eventData?.status === TOOL_CALL_STATUS.generating) return false
+  const toolCallId = getToolCallIdFromEvent(event)
+  if (!toolCallId) return false
+  if (eventData?.partial === true) return false
+  if (wasToolResultSeen(toolCallId) || wasToolCallSeen(toolCallId)) return true
+  markToolCallSeen(toolCallId)
+  return false
+}
+
+export function shouldSkipToolResultEvent(event: StreamEvent): boolean {
+  if (event.type !== MothershipStreamV1EventType.tool) return false
+  const eventData = getEventData(event)
+  if (eventData?.phase !== MothershipStreamV1ToolPhase.result) return false
+  const toolCallId = getToolCallIdFromEvent(event)
+  if (!toolCallId) return false
+  return wasToolResultSeen(toolCallId)
+}
diff --git a/apps/sim/lib/copilot/orchestrator/subagent.ts b/apps/sim/lib/copilot/request/subagent.ts
similarity index 77%
rename from apps/sim/lib/copilot/orchestrator/subagent.ts
rename to apps/sim/lib/copilot/request/subagent.ts
index 0fc6716bc6c..4e2d17cc388 100644
--- a/apps/sim/lib/copilot/orchestrator/subagent.ts
+++ b/apps/sim/lib/copilot/request/subagent.ts
@@ -1,17 +1,23 @@
 import { createLogger } from '@sim/logger'
 import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { prepareExecutionContext } from '@/lib/copilot/orchestrator/tool-executor'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanPayloadKind,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
+import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
+import { runStreamLoop } from '@/lib/copilot/request/go/stream'
 import type {
   ExecutionContext,
   OrchestratorOptions,
-  SSEEvent,
+  StreamEvent,
   StreamingContext,
   ToolCallSummary,
-} from '@/lib/copilot/orchestrator/types'
+} from '@/lib/copilot/request/types'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
 import { env } from '@/lib/core/config/env'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { buildToolCallSummaries, createStreamingContext, runStreamLoop } from './stream/core'
 
 const logger = createLogger('CopilotSubagentOrchestrator')
 
@@ -72,23 +78,22 @@ export async function orchestrateSubagentStream(
       execContext,
       {
         ...options,
-        onBeforeDispatch: (event: SSEEvent, ctx: StreamingContext) => {
-          // Handle structured_result / subagent_result - subagent-specific.
-          if (event.type === 'structured_result' || event.type === 'subagent_result') {
-            structuredResult = normalizeStructuredResult(event.data)
+        onBeforeDispatch: (event: StreamEvent, ctx: StreamingContext) => {
+          if (
+            event.type === MothershipStreamV1EventType.span &&
+            (event.payload.kind === MothershipStreamV1SpanPayloadKind.structured_result ||
+              event.payload.kind === MothershipStreamV1SpanPayloadKind.subagent_result)
+          ) {
+            structuredResult = normalizeStructuredResult(event.payload.data)
             ctx.streamComplete = true
-            return true // skip default dispatch
+            return true
           }
 
-          // For direct subagent calls, events may have the subagent field set
-          // but no subagent_start because this IS the top-level agent.
-          // Skip subagent routing for events where the subagent field matches
-          // the current agentId - these are top-level events.
-          if (event.subagent === agentId && !ctx.subAgentParentToolCallId) {
-            return false // let default dispatch handle it
+          if (event.scope?.agentId === agentId && !ctx.subAgentParentToolCallId) {
+            return false
           }
 
-          return false // let default dispatch handle it
+          return false
         },
       }
     )
diff --git a/apps/sim/lib/copilot/request/tools/billing.ts b/apps/sim/lib/copilot/request/tools/billing.ts
new file mode 100644
index 00000000000..2f4b0e2d7ac
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/billing.ts
@@ -0,0 +1,84 @@
+import { createLogger } from '@sim/logger'
+import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
+import { isPaid } from '@/lib/billing/plan-helpers'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { sseHandlers } from '@/lib/copilot/request/handlers'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+
+const logger = createLogger('CopilotBillingEffect')
+
+/**
+ * Handle a 402 billing-limit response from the Go backend.
+ *
+ * Determines whether the user needs a plan upgrade or a limit increase,
+ * then dispatches synthetic text + complete events through the handler chain
+ * so the client renders the upgrade prompt.
+ */
+export async function handleBillingLimitResponse(
+  userId: string,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions
+): Promise<void> {
+  let action = 'upgrade_plan'
+  let message = "You've reached your usage limit. Please upgrade your plan to continue."
+  try {
+    const sub = await getHighestPrioritySubscription(userId)
+    if (sub && isPaid(sub.plan)) {
+      action = 'increase_limit'
+      message =
+        "You've reached your usage limit for this billing period. Please increase your usage limit to continue."
+    }
+  } catch {
+    logger.warn('Failed to determine subscription plan, defaulting to upgrade_plan')
+  }
+
+  const upgradePayload = JSON.stringify({
+    reason: 'usage_limit',
+    action,
+    message,
+  })
+  const syntheticContent = `<usage_upgrade>${upgradePayload}</usage_upgrade>`
+
+  const syntheticEvents: StreamEvent[] = [
+    {
+      type: MothershipStreamV1EventType.text,
+      payload: {
+        channel: MothershipStreamV1TextChannel.assistant,
+        text: syntheticContent,
+      },
+    },
+    {
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: MothershipStreamV1CompletionStatus.complete,
+      },
+    },
+  ]
+
+  for (const event of syntheticEvents) {
+    try {
+      await options.onEvent?.(event)
+    } catch {
+      logger.warn('Failed to forward synthetic billing event', { type: event.type })
+    }
+
+    // TODO: Handler dispatch should move out of this effect — effects should be
+    // pure side-effect producers; event dispatch belongs in the stream loop or
+    // a dedicated dispatcher. Keeping here for now to preserve behavior.
+    const handler = sseHandlers[event.type]
+    if (handler) {
+      await handler(event, context, execContext, options)
+    }
+    if (context.streamComplete) break
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/client.ts b/apps/sim/lib/copilot/request/tools/client.ts
new file mode 100644
index 00000000000..44f2341486f
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/client.ts
@@ -0,0 +1,43 @@
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { waitForToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
+
+/**
+ * Wait for a tool completion signal (success/error/rejected) from the client.
+ * Ignores intermediate statuses like `accepted` and only returns terminal statuses:
+ * - success: client finished executing successfully
+ * - error: client execution failed
+ * - rejected: user clicked Skip (subagent run tools where user hasn't auto-allowed)
+ *
+ * Used for client-executable run tools: the client executes the workflow
+ * and posts success/error to /api/copilot/confirm when done. The server
+ * waits here until that completion signal arrives.
+ */
+export async function waitForToolCompletion(
+  toolCallId: string,
+  timeoutMs: number,
+  abortSignal?: AbortSignal
+): Promise<{ status: string; message?: string; data?: Record<string, unknown> } | null> {
+  const decision = await waitForToolConfirmation(toolCallId, timeoutMs, abortSignal, {
+    acceptStatus: (status) =>
+      status === MothershipStreamV1ToolOutcome.success ||
+      status === MothershipStreamV1ToolOutcome.error ||
+      status === MothershipStreamV1ToolOutcome.rejected ||
+      status === 'background' ||
+      status === MothershipStreamV1ToolOutcome.cancelled ||
+      status === MothershipStreamV1AsyncToolRecordStatus.delivered,
+  })
+  if (
+    decision?.status === MothershipStreamV1ToolOutcome.success ||
+    decision?.status === MothershipStreamV1ToolOutcome.error ||
+    decision?.status === MothershipStreamV1ToolOutcome.rejected ||
+    decision?.status === 'background' ||
+    decision?.status === MothershipStreamV1ToolOutcome.cancelled ||
+    decision?.status === MothershipStreamV1AsyncToolRecordStatus.delivered
+  ) {
+    return decision
+  }
+  return null
+}
diff --git a/apps/sim/lib/copilot/request/tools/executor.ts b/apps/sim/lib/copilot/request/tools/executor.ts
new file mode 100644
index 00000000000..1179ca48ce8
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/executor.ts
@@ -0,0 +1,490 @@
+import { createLogger } from '@sim/logger'
+import {
+  completeAsyncToolCall,
+  markAsyncToolRunning,
+  upsertAsyncToolCall,
+} from '@/lib/copilot/async-runs/repository'
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { CreateWorkflow } from '@/lib/copilot/generated/tool-catalog-v1'
+import { publishToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
+import { asRecord, markToolResultSeen } from '@/lib/copilot/request/sse-utils'
+import { maybeWriteOutputToFile } from '@/lib/copilot/request/tools/files'
+import { handleResourceSideEffects } from '@/lib/copilot/request/tools/resources'
+import {
+  maybeWriteOutputToTable,
+  maybeWriteReadCsvToTable,
+} from '@/lib/copilot/request/tools/tables'
+import {
+  type ExecutionContext,
+  isTerminalToolCallStatus,
+  type OrchestratorOptions,
+  type StreamEvent,
+  type StreamingContext,
+} from '@/lib/copilot/request/types'
+import { ensureHandlersRegistered, executeTool } from '@/lib/copilot/tool-executor'
+
+export { waitForToolCompletion } from '@/lib/copilot/request/tools/client'
+
+const logger = createLogger('CopilotSseToolExecution')
+
+export interface AsyncToolCompletion {
+  status: string
+  message?: string
+  data?: Record<string, unknown>
+}
+
+function publishTerminalToolConfirmation(input: {
+  toolCallId: string
+  status: string
+  message?: string
+  data?: Record<string, unknown>
+}): void {
+  publishToolConfirmation({
+    toolCallId: input.toolCallId,
+    status: input.status,
+    message: input.message,
+    data: input.data,
+    timestamp: new Date().toISOString(),
+  })
+}
+
+function abortRequested(
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options?: OrchestratorOptions
+): boolean {
+  return Boolean(
+    options?.abortSignal?.aborted || execContext.abortSignal?.aborted || context.wasAborted
+  )
+}
+
+function cancelledCompletion(message: string): AsyncToolCompletion {
+  return {
+    status: MothershipStreamV1ToolOutcome.cancelled,
+    message,
+    data: { cancelled: true },
+  }
+}
+
+function terminalCompletionFromToolCall(toolCall: {
+  status: string
+  error?: string
+  result?: { output?: unknown; error?: string }
+}): AsyncToolCompletion {
+  if (toolCall.status === MothershipStreamV1ToolOutcome.cancelled) {
+    return cancelledCompletion(toolCall.error || 'Tool execution cancelled')
+  }
+
+  if (toolCall.status === MothershipStreamV1ToolOutcome.success) {
+    return {
+      status: MothershipStreamV1ToolOutcome.success,
+      message: 'Tool completed',
+      data:
+        toolCall.result?.output &&
+        typeof toolCall.result.output === 'object' &&
+        !Array.isArray(toolCall.result.output)
+          ? (toolCall.result.output as Record<string, unknown>)
+          : undefined,
+    }
+  }
+
+  if (toolCall.status === MothershipStreamV1ToolOutcome.skipped) {
+    return {
+      status: MothershipStreamV1ToolOutcome.success,
+      message: 'Tool skipped',
+      data:
+        toolCall.result?.output &&
+        typeof toolCall.result.output === 'object' &&
+        !Array.isArray(toolCall.result.output)
+          ? (toolCall.result.output as Record<string, unknown>)
+          : undefined,
+    }
+  }
+
+  return {
+    status:
+      toolCall.status === MothershipStreamV1ToolOutcome.rejected
+        ? MothershipStreamV1ToolOutcome.rejected
+        : MothershipStreamV1ToolOutcome.error,
+    message: toolCall.error || toolCall.result?.error || 'Tool failed',
+    data: { error: toolCall.error || toolCall.result?.error || 'Tool failed' },
+  }
+}
+
+export async function executeToolAndReport(
+  toolCallId: string,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options?: OrchestratorOptions
+): Promise<AsyncToolCompletion> {
+  const toolCall = context.toolCalls.get(toolCallId)
+  if (!toolCall)
+    return { status: MothershipStreamV1ToolOutcome.error, message: 'Tool call not found' }
+
+  if (toolCall.status === 'executing') {
+    return {
+      status: MothershipStreamV1AsyncToolRecordStatus.running,
+      message: 'Tool already executing',
+    }
+  }
+  if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
+    return terminalCompletionFromToolCall(toolCall)
+  }
+
+  if (abortRequested(context, execContext, options)) {
+    toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+    toolCall.endTime = Date.now()
+    markToolResultSeen(toolCall.id)
+    await completeAsyncToolCall({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+      result: { cancelled: true },
+      error: 'Request aborted before tool execution',
+    }).catch((err) => {
+      logger.warn('Failed to persist async tool status', {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    publishTerminalToolConfirmation({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1ToolOutcome.cancelled,
+      message: 'Request aborted before tool execution',
+      data: { cancelled: true },
+    })
+    return cancelledCompletion('Request aborted before tool execution')
+  }
+
+  toolCall.status = 'executing'
+  await upsertAsyncToolCall({
+    runId: context.runId || crypto.randomUUID(),
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    args: toolCall.params,
+  }).catch((err) => {
+    logger.warn('Failed to persist async tool row before execution', {
+      toolCallId: toolCall.id,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  })
+  await markAsyncToolRunning(toolCall.id, 'sim-stream').catch((err) => {
+    logger.warn('Failed to mark async tool running', {
+      toolCallId: toolCall.id,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  })
+
+  if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
+    return terminalCompletionFromToolCall(toolCall)
+  }
+
+  const argsPreview = toolCall.params ? JSON.stringify(toolCall.params).slice(0, 200) : undefined
+  const toolSpan = context.trace.startSpan(toolCall.name, 'tool.execute', {
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    argsPreview,
+  })
+
+  logger.info('Tool execution started', {
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+  })
+
+  try {
+    ensureHandlersRegistered()
+    let result = await executeTool(toolCall.name, toolCall.params || {}, execContext)
+    if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
+      return terminalCompletionFromToolCall(toolCall)
+    }
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      toolCall.endTime = Date.now()
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool execution',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool execution',
+        data: { cancelled: true },
+      })
+      return cancelledCompletion('Request aborted during tool execution')
+    }
+    result = await maybeWriteOutputToFile(toolCall.name, toolCall.params, result, execContext)
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      toolCall.endTime = Date.now()
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool post-processing',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool post-processing',
+        data: { cancelled: true },
+      })
+      return cancelledCompletion('Request aborted during tool post-processing')
+    }
+    result = await maybeWriteOutputToTable(toolCall.name, toolCall.params, result, execContext)
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      toolCall.endTime = Date.now()
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool post-processing',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool post-processing',
+        data: { cancelled: true },
+      })
+      return cancelledCompletion('Request aborted during tool post-processing')
+    }
+    result = await maybeWriteReadCsvToTable(toolCall.name, toolCall.params, result, execContext)
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      toolCall.endTime = Date.now()
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool post-processing',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool post-processing',
+        data: { cancelled: true },
+      })
+      return cancelledCompletion('Request aborted during tool post-processing')
+    }
+    toolCall.status = result.success
+      ? MothershipStreamV1ToolOutcome.success
+      : MothershipStreamV1ToolOutcome.error
+    toolCall.result = result
+    toolCall.error = result.error
+    toolCall.endTime = Date.now()
+
+    if (result.success) {
+      const raw = result.output
+      const preview =
+        typeof raw === 'string'
+          ? raw.slice(0, 200)
+          : raw && typeof raw === 'object'
+            ? JSON.stringify(raw).slice(0, 200)
+            : undefined
+      logger.info('Tool execution succeeded', {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        outputPreview: preview,
+      })
+    } else {
+      logger.warn('Tool execution failed', {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        error: result.error,
+        params: toolCall.params,
+      })
+    }
+
+    // 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.
+    const output = asRecord(result.output)
+    if (
+      toolCall.name === CreateWorkflow.id &&
+      result.success &&
+      output.workflowId &&
+      !execContext.workflowId
+    ) {
+      execContext.workflowId = output.workflowId as string
+      if (output.workspaceId) {
+        execContext.workspaceId = output.workspaceId as string
+      }
+    }
+
+    markToolResultSeen(toolCall.id)
+    await completeAsyncToolCall({
+      toolCallId: toolCall.id,
+      status: result.success
+        ? MothershipStreamV1AsyncToolRecordStatus.completed
+        : MothershipStreamV1AsyncToolRecordStatus.failed,
+      result: result.success ? asRecord(result.output) : { error: result.error || 'Tool failed' },
+      error: result.success ? null : result.error || 'Tool failed',
+    }).catch((err) => {
+      logger.warn('Failed to persist async tool completion', {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    publishTerminalToolConfirmation({
+      toolCallId: toolCall.id,
+      status: result.success
+        ? MothershipStreamV1ToolOutcome.success
+        : MothershipStreamV1ToolOutcome.error,
+      message: result.error || (result.success ? 'Tool completed' : 'Tool failed'),
+      data: asRecord(result.output),
+    })
+
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      return cancelledCompletion('Request aborted before tool result delivery')
+    }
+
+    // Fire-and-forget: notify the copilot backend that the tool completed.
+    // IMPORTANT: We must NOT await this — the Go backend may block on the
+    const resultEvent: StreamEvent = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        success: result.success,
+        result: result.output,
+        ...(result.success
+          ? { status: MothershipStreamV1ToolOutcome.success }
+          : { status: MothershipStreamV1ToolOutcome.error }),
+      },
+    }
+    await options?.onEvent?.(resultEvent)
+
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      return cancelledCompletion('Request aborted before resource persistence')
+    }
+
+    if (result.success && execContext.chatId && !abortRequested(context, execContext, options)) {
+      await handleResourceSideEffects(
+        toolCall.name,
+        toolCall.params,
+        result,
+        execContext.chatId,
+        options?.onEvent,
+        () => abortRequested(context, execContext, options)
+      )
+    }
+    context.trace.endSpan(toolSpan, result.success ? 'ok' : 'error')
+    return {
+      status: result.success
+        ? MothershipStreamV1ToolOutcome.success
+        : MothershipStreamV1ToolOutcome.error,
+      message: result.error || (result.success ? 'Tool completed' : 'Tool failed'),
+      data: asRecord(result.output),
+    }
+  } catch (error) {
+    context.trace.endSpan(toolSpan, 'error')
+    if (abortRequested(context, execContext, options)) {
+      toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+      toolCall.endTime = Date.now()
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool execution',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool execution',
+        data: { cancelled: true },
+      })
+      return cancelledCompletion('Request aborted during tool execution')
+    }
+    toolCall.status = MothershipStreamV1ToolOutcome.error
+    toolCall.error = error instanceof Error ? error.message : String(error)
+    toolCall.endTime = Date.now()
+
+    logger.error('Tool execution threw', {
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      error: toolCall.error,
+      params: toolCall.params,
+    })
+
+    markToolResultSeen(toolCall.id)
+    await completeAsyncToolCall({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1AsyncToolRecordStatus.failed,
+      result: { error: toolCall.error },
+      error: toolCall.error,
+    }).catch((err) => {
+      logger.warn('Failed to persist async tool error', {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    publishTerminalToolConfirmation({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1ToolOutcome.error,
+      message: toolCall.error,
+      data: { error: toolCall.error },
+    })
+
+    const errorEvent: StreamEvent = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        status: MothershipStreamV1ToolOutcome.error,
+        error: toolCall.error,
+        result: { error: toolCall.error },
+      },
+    }
+    await options?.onEvent?.(errorEvent)
+    return {
+      status: MothershipStreamV1ToolOutcome.error,
+      message: toolCall.error,
+      data: { error: toolCall.error },
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/files.ts b/apps/sim/lib/copilot/request/tools/files.ts
new file mode 100644
index 00000000000..64bb4bf6a1d
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/files.ts
@@ -0,0 +1,200 @@
+import { createLogger } from '@sim/logger'
+import { FunctionExecute, UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('CopilotToolResultFiles')
+
+export const OUTPUT_PATH_TOOLS: Set<string> = new Set([FunctionExecute.id, UserTable.id])
+
+type OutputFormat = 'json' | 'csv' | 'txt' | 'md' | 'html'
+
+export const EXT_TO_FORMAT: Record<string, OutputFormat> = {
+  '.json': 'json',
+  '.csv': 'csv',
+  '.txt': 'txt',
+  '.md': 'md',
+  '.html': 'html',
+}
+
+export const FORMAT_TO_CONTENT_TYPE: Record<OutputFormat, string> = {
+  json: 'application/json',
+  csv: 'text/csv',
+  txt: 'text/plain',
+  md: 'text/markdown',
+  html: 'text/html',
+}
+
+/**
+ * Try to pull a flat array of row-objects out of the various shapes that
+ * `function_execute` and `user_table` can return.
+ */
+export function extractTabularData(output: unknown): Record<string, unknown>[] | null {
+  if (!output || typeof output !== 'object') return null
+
+  if (Array.isArray(output)) {
+    if (output.length > 0 && typeof output[0] === 'object' && output[0] !== null) {
+      return output as Record<string, unknown>[]
+    }
+    return null
+  }
+
+  const obj = output as Record<string, unknown>
+
+  // function_execute shape: { result: [...], stdout: "..." }
+  if (Array.isArray(obj.result)) {
+    const rows = obj.result
+    if (rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null) {
+      return rows as Record<string, unknown>[]
+    }
+  }
+
+  // user_table query_rows shape: { data: { rows: [{ data: {...} }], totalCount } }
+  if (obj.data && typeof obj.data === 'object' && !Array.isArray(obj.data)) {
+    const data = obj.data as Record<string, unknown>
+    if (Array.isArray(data.rows) && data.rows.length > 0) {
+      const rows = data.rows as Record<string, unknown>[]
+      if (typeof rows[0].data === 'object' && rows[0].data !== null) {
+        return rows.map((r) => r.data as Record<string, unknown>)
+      }
+      return rows
+    }
+  }
+
+  return null
+}
+
+export function escapeCsvValue(value: unknown): string {
+  if (value === null || value === undefined) return ''
+  const str = typeof value === 'object' ? JSON.stringify(value) : String(value)
+  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+    return `"${str.replace(/"/g, '""')}"`
+  }
+  return str
+}
+
+export function convertRowsToCsv(rows: Record<string, unknown>[]): string {
+  if (rows.length === 0) return ''
+
+  const headerSet = new Set<string>()
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      headerSet.add(key)
+    }
+  }
+  const headers = [...headerSet]
+
+  const lines = [headers.map(escapeCsvValue).join(',')]
+  for (const row of rows) {
+    lines.push(headers.map((h) => escapeCsvValue(row[h])).join(','))
+  }
+  return lines.join('\n')
+}
+
+export function normalizeOutputWorkspaceFileName(outputPath: string): string {
+  const trimmed = outputPath.trim().replace(/^\/+/, '')
+  const withoutPrefix = trimmed.startsWith('files/') ? trimmed.slice('files/'.length) : trimmed
+  if (!withoutPrefix) {
+    throw new Error('outputPath must include a file name, e.g. "files/result.json"')
+  }
+  if (withoutPrefix.includes('/')) {
+    throw new Error(
+      'outputPath must target a flat workspace file, e.g. "files/result.json". Nested paths like "files/reports/result.json" are not supported.'
+    )
+  }
+  return withoutPrefix
+}
+
+export function resolveOutputFormat(fileName: string, explicit?: string): OutputFormat {
+  if (explicit && explicit in FORMAT_TO_CONTENT_TYPE) return explicit as OutputFormat
+  const ext = fileName.slice(fileName.lastIndexOf('.')).toLowerCase()
+  return EXT_TO_FORMAT[ext] ?? 'json'
+}
+
+export function serializeOutputForFile(output: unknown, format: OutputFormat): string {
+  if (typeof output === 'string') return output
+
+  if (format === 'csv') {
+    const rows = extractTabularData(output)
+    if (rows && rows.length > 0) {
+      return convertRowsToCsv(rows)
+    }
+  }
+
+  return JSON.stringify(output, null, 2)
+}
+
+export async function maybeWriteOutputToFile(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  if (!result.success || !result.output) return result
+  if (!OUTPUT_PATH_TOOLS.has(toolName)) return result
+  if (!context.workspaceId || !context.userId) return result
+
+  const args = params?.args as Record<string, unknown> | undefined
+  const outputPath =
+    (params?.outputPath as string | undefined) ?? (args?.outputPath as string | undefined)
+  if (!outputPath) return result
+  const outputSandboxPath =
+    (params?.outputSandboxPath as string | undefined) ??
+    (args?.outputSandboxPath as string | undefined)
+  if (toolName === FunctionExecute.id && outputSandboxPath) return result
+
+  const explicitFormat =
+    (params?.outputFormat as string | undefined) ?? (args?.outputFormat as string | undefined)
+
+  try {
+    const fileName = normalizeOutputWorkspaceFileName(outputPath)
+    const format = resolveOutputFormat(fileName, explicitFormat)
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    const content = serializeOutputForFile(result.output, format)
+    const contentType = FORMAT_TO_CONTENT_TYPE[format]
+
+    const buffer = Buffer.from(content, 'utf-8')
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    const uploaded = await uploadWorkspaceFile(
+      context.workspaceId,
+      context.userId,
+      buffer,
+      fileName,
+      contentType
+    )
+
+    logger.info('Tool output written to file', {
+      toolName,
+      fileName,
+      size: buffer.length,
+      fileId: uploaded.id,
+    })
+
+    return {
+      success: true,
+      output: {
+        message: `Output written to files/${fileName} (${buffer.length} bytes)`,
+        fileId: uploaded.id,
+        fileName,
+        size: buffer.length,
+        downloadUrl: uploaded.url,
+      },
+      resources: [{ type: 'file', id: uploaded.id, title: fileName }],
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    logger.warn('Failed to write tool output to file', {
+      toolName,
+      outputPath,
+      error: message,
+    })
+    return {
+      success: false,
+      error: `Failed to write output file: ${message}`,
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/resources.ts b/apps/sim/lib/copilot/request/tools/resources.ts
new file mode 100644
index 00000000000..b14f0caf79e
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/resources.ts
@@ -0,0 +1,91 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1ResourceOp,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent, ToolCallResult } from '@/lib/copilot/request/types'
+import {
+  extractDeletedResourcesFromToolResult,
+  extractResourcesFromToolResult,
+  hasDeleteCapability,
+  isResourceToolName,
+  persistChatResources,
+  removeChatResources,
+} from '@/lib/copilot/resources/persistence'
+
+const logger = createLogger('CopilotResourceEffects')
+
+/**
+ * Persist and emit resource events after a successful tool execution.
+ *
+ * Handles both creation/upsert and deletion of chat resources depending on
+ * the tool's capabilities and output shape.
+ */
+export async function handleResourceSideEffects(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  chatId: string,
+  onEvent: ((event: StreamEvent) => void | Promise<void>) | undefined,
+  isAborted: () => boolean
+): Promise<void> {
+  let isDeleteOp = false
+
+  if (hasDeleteCapability(toolName)) {
+    const deleted = extractDeletedResourcesFromToolResult(toolName, params, result.output)
+    if (deleted.length > 0) {
+      isDeleteOp = true
+      removeChatResources(chatId, deleted).catch((err) => {
+        logger.warn('Failed to remove chat resources after deletion', {
+          chatId,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+
+      for (const resource of deleted) {
+        if (isAborted()) break
+        await onEvent?.({
+          type: MothershipStreamV1EventType.resource,
+          payload: {
+            op: MothershipStreamV1ResourceOp.remove,
+            resource: { type: resource.type, id: resource.id, title: resource.title },
+          },
+        })
+      }
+    }
+  }
+
+  if (!isDeleteOp && !isAborted()) {
+    const resources =
+      result.resources && result.resources.length > 0
+        ? result.resources
+        : isResourceToolName(toolName)
+          ? extractResourcesFromToolResult(toolName, params, result.output)
+          : []
+
+    if (resources.length > 0) {
+      logger.info('[file-stream-server] Emitting resource upsert events', {
+        toolName,
+        chatId,
+        resources: resources.map((r) => ({ type: r.type, id: r.id, title: r.title })),
+      })
+      persistChatResources(chatId, resources).catch((err) => {
+        logger.warn('Failed to persist chat resources', {
+          chatId,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+
+      for (const resource of resources) {
+        if (isAborted()) break
+        await onEvent?.({
+          type: MothershipStreamV1EventType.resource,
+          payload: {
+            op: MothershipStreamV1ResourceOp.upsert,
+            resource: { type: resource.type, id: resource.id, title: resource.title },
+          },
+        })
+      }
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/tables.ts b/apps/sim/lib/copilot/request/tools/tables.ts
new file mode 100644
index 00000000000..89e0a5c19f0
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/tables.ts
@@ -0,0 +1,248 @@
+import { db } from '@sim/db'
+import { userTableRows } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { parse as csvParse } from 'csv-parse/sync'
+import { eq } from 'drizzle-orm'
+import { FunctionExecute, Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { getTableById } from '@/lib/table/service'
+
+const logger = createLogger('CopilotToolResultTables')
+
+const MAX_OUTPUT_TABLE_ROWS = 10_000
+const BATCH_CHUNK_SIZE = 500
+
+export async function maybeWriteOutputToTable(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  if (toolName !== FunctionExecute.id) return result
+  if (!result.success || !result.output) return result
+  if (!context.workspaceId || !context.userId) return result
+
+  const outputTable = params?.outputTable as string | undefined
+  if (!outputTable) return result
+
+  try {
+    const table = await getTableById(outputTable)
+    if (!table) {
+      return {
+        success: false,
+        error: `Table "${outputTable}" not found`,
+      }
+    }
+
+    const rawOutput = result.output
+    let rows: Array<Record<string, unknown>>
+
+    if (rawOutput && typeof rawOutput === 'object' && 'result' in rawOutput) {
+      const inner = (rawOutput as Record<string, unknown>).result
+      if (Array.isArray(inner)) {
+        rows = inner
+      } else {
+        return {
+          success: false,
+          error: 'outputTable requires the code to return an array of objects',
+        }
+      }
+    } else if (Array.isArray(rawOutput)) {
+      rows = rawOutput
+    } else {
+      return {
+        success: false,
+        error: 'outputTable requires the code to return an array of objects',
+      }
+    }
+
+    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
+      return {
+        success: false,
+        error: `outputTable row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
+      }
+    }
+
+    if (rows.length === 0) {
+      return {
+        success: false,
+        error: 'outputTable requires at least one row — code returned an empty array',
+      }
+    }
+
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    await db.transaction(async (tx) => {
+      if (context.abortSignal?.aborted) {
+        throw new Error('Request aborted before tool mutation could be applied')
+      }
+      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
+
+      const now = new Date()
+      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
+        if (context.abortSignal?.aborted) {
+          throw new Error('Request aborted before tool mutation could be applied')
+        }
+        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
+        const values = chunk.map((rowData, j) => ({
+          id: `row_${crypto.randomUUID().replace(/-/g, '')}`,
+          tableId: outputTable,
+          workspaceId: context.workspaceId!,
+          data: rowData,
+          position: i + j,
+          createdAt: now,
+          updatedAt: now,
+          createdBy: context.userId,
+        }))
+        await tx.insert(userTableRows).values(values)
+      }
+    })
+
+    logger.info('Tool output written to table', {
+      toolName,
+      tableId: outputTable,
+      rowCount: rows.length,
+    })
+
+    return {
+      success: true,
+      output: {
+        message: `Wrote ${rows.length} rows to table ${outputTable}`,
+        tableId: outputTable,
+        rowCount: rows.length,
+      },
+    }
+  } catch (err) {
+    logger.warn('Failed to write tool output to table', {
+      toolName,
+      outputTable,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return {
+      success: false,
+      error: `Failed to write to table: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}
+
+export async function maybeWriteReadCsvToTable(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  if (toolName !== ReadTool.id) return result
+  if (!result.success || !result.output) return result
+  if (!context.workspaceId || !context.userId) return result
+
+  const outputTable = params?.outputTable as string | undefined
+  if (!outputTable) return result
+
+  try {
+    const table = await getTableById(outputTable)
+    if (!table) {
+      return { success: false, error: `Table "${outputTable}" not found` }
+    }
+
+    const output = result.output as Record<string, unknown>
+    const content = (output.content as string) || ''
+    if (!content.trim()) {
+      return { success: false, error: 'File has no content to import into table' }
+    }
+
+    const filePath = (params?.path as string) || ''
+    const ext = filePath.split('.').pop()?.toLowerCase()
+
+    let rows: Record<string, unknown>[]
+
+    if (ext === 'json') {
+      const parsed = JSON.parse(content)
+      if (!Array.isArray(parsed)) {
+        return {
+          success: false,
+          error: 'JSON file must contain an array of objects for table import',
+        }
+      }
+      rows = parsed
+    } else {
+      rows = csvParse(content, {
+        columns: true,
+        skip_empty_lines: true,
+        trim: true,
+        relax_column_count: true,
+        relax_quotes: true,
+        skip_records_with_error: true,
+        cast: false,
+      }) as Record<string, unknown>[]
+    }
+
+    if (rows.length === 0) {
+      return { success: false, error: 'File has no data rows to import' }
+    }
+
+    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
+      return {
+        success: false,
+        error: `Row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
+      }
+    }
+
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    await db.transaction(async (tx) => {
+      if (context.abortSignal?.aborted) {
+        throw new Error('Request aborted before tool mutation could be applied')
+      }
+      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
+
+      const now = new Date()
+      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
+        if (context.abortSignal?.aborted) {
+          throw new Error('Request aborted before tool mutation could be applied')
+        }
+        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
+        const values = chunk.map((rowData, j) => ({
+          id: `row_${crypto.randomUUID().replace(/-/g, '')}`,
+          tableId: outputTable,
+          workspaceId: context.workspaceId!,
+          data: rowData,
+          position: i + j,
+          createdAt: now,
+          updatedAt: now,
+          createdBy: context.userId,
+        }))
+        await tx.insert(userTableRows).values(values)
+      }
+    })
+
+    logger.info('Read output written to table', {
+      toolName,
+      tableId: outputTable,
+      tableName: table.name,
+      rowCount: rows.length,
+      filePath,
+    })
+
+    return {
+      success: true,
+      output: {
+        message: `Imported ${rows.length} rows from "${filePath}" into table "${table.name}"`,
+        tableId: outputTable,
+        tableName: table.name,
+        rowCount: rows.length,
+      },
+    }
+  } catch (err) {
+    logger.warn('Failed to write read output to table', {
+      toolName,
+      outputTable,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return {
+      success: false,
+      error: `Failed to import into table: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/trace.ts b/apps/sim/lib/copilot/request/trace.ts
new file mode 100644
index 00000000000..72353f19845
--- /dev/null
+++ b/apps/sim/lib/copilot/request/trace.ts
@@ -0,0 +1,125 @@
+import { createLogger } from '@sim/logger'
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import {
+  type RequestTraceV1CostSummary,
+  RequestTraceV1Outcome,
+  type RequestTraceV1SimReport,
+  type RequestTraceV1Span,
+  RequestTraceV1SpanSource,
+  RequestTraceV1SpanStatus,
+  type RequestTraceV1UsageSummary,
+} from '@/lib/copilot/generated/request-trace-v1'
+import { env } from '@/lib/core/config/env'
+
+const logger = createLogger('RequestTrace')
+
+export class TraceCollector {
+  private readonly spans: RequestTraceV1Span[] = []
+  private readonly startMs = Date.now()
+  private goTraceId?: string
+  private activeSpan?: RequestTraceV1Span
+
+  startSpan(
+    name: string,
+    kind: string,
+    attributes?: Record<string, unknown>,
+    parent?: RequestTraceV1Span
+  ): RequestTraceV1Span {
+    const span: RequestTraceV1Span = {
+      name,
+      kind,
+      startMs: Date.now(),
+      status: RequestTraceV1SpanStatus.ok,
+      source: RequestTraceV1SpanSource.sim,
+      ...(parent
+        ? { parentName: parent.name }
+        : this.activeSpan
+          ? { parentName: this.activeSpan.name }
+          : {}),
+      ...(attributes && Object.keys(attributes).length > 0 ? { attributes } : {}),
+    }
+    this.spans.push(span)
+    return span
+  }
+
+  endSpan(
+    span: RequestTraceV1Span,
+    status: RequestTraceV1SpanStatus | string = RequestTraceV1SpanStatus.ok
+  ): void {
+    span.endMs = Date.now()
+    span.durationMs = span.endMs - span.startMs
+    span.status = status as RequestTraceV1SpanStatus
+  }
+
+  setActiveSpan(span: RequestTraceV1Span | undefined): void {
+    this.activeSpan = span
+  }
+
+  setGoTraceId(id: string): void {
+    if (!this.goTraceId && id) {
+      this.goTraceId = id
+    }
+  }
+
+  build(params: {
+    outcome: RequestTraceV1Outcome
+    simRequestId: string
+    streamId?: string
+    chatId?: string
+    runId?: string
+    executionId?: string
+    usage?: { prompt: number; completion: number }
+    cost?: { input: number; output: number; total: number }
+  }): RequestTraceV1SimReport {
+    const endMs = Date.now()
+    const usage: RequestTraceV1UsageSummary | undefined = params.usage
+      ? {
+          inputTokens: params.usage.prompt,
+          outputTokens: params.usage.completion,
+        }
+      : undefined
+
+    const cost: RequestTraceV1CostSummary | undefined = params.cost
+      ? {
+          rawTotalCost: params.cost.total,
+          billedTotalCost: params.cost.total,
+        }
+      : undefined
+
+    return {
+      simRequestId: params.simRequestId,
+      goTraceId: this.goTraceId,
+      streamId: params.streamId,
+      chatId: params.chatId,
+      runId: params.runId,
+      executionId: params.executionId,
+      startMs: this.startMs,
+      endMs,
+      durationMs: endMs - this.startMs,
+      outcome: params.outcome,
+      usage,
+      cost,
+      spans: this.spans,
+    }
+  }
+}
+
+export async function reportTrace(trace: RequestTraceV1SimReport): Promise<void> {
+  const response = await fetch(`${SIM_AGENT_API_URL}/api/traces`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+    },
+    body: JSON.stringify(trace),
+  })
+
+  if (!response.ok) {
+    logger.warn('Failed to report trace', {
+      status: response.status,
+      simRequestId: trace.simRequestId,
+    })
+  }
+}
+
+export { RequestTraceV1Outcome, RequestTraceV1SpanStatus }
diff --git a/apps/sim/lib/copilot/orchestrator/types.ts b/apps/sim/lib/copilot/request/types.ts
similarity index 52%
rename from apps/sim/lib/copilot/orchestrator/types.ts
rename to apps/sim/lib/copilot/request/types.ts
index b5a9e412f8e..5114fa5e5ea 100644
--- a/apps/sim/lib/copilot/orchestrator/types.ts
+++ b/apps/sim/lib/copilot/request/types.ts
@@ -1,71 +1,16 @@
-import type { MothershipResource } from '@/lib/copilot/resource-types'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent } from '@/lib/copilot/request/session'
+import type { TraceCollector } from '@/lib/copilot/request/trace'
+import type { ToolExecutionContext, ToolExecutionResult } from '@/lib/copilot/tool-executor/types'
 
-export type SSEEventType =
-  | 'chat_id'
-  | 'request_id'
-  | 'title_updated'
-  | 'content'
-  | 'reasoning'
-  | 'tool_call'
-  | 'tool_call_delta'
-  | 'tool_generating'
-  | 'tool_result'
-  | 'tool_error'
-  | 'resource_added'
-  | 'resource_deleted'
-  | 'subagent_start'
-  | 'subagent_end'
-  | 'structured_result'
-  | 'subagent_result'
-  | 'done'
-  | 'error'
-  | 'start'
+export type { StreamEvent }
 
-export interface SSEEvent {
-  type: SSEEventType
-  /** Authoritative tool call state set by the server */
-  state?: string
-  data?: Record<string, unknown>
-  /** Parent agent that produced this event */
-  agent?: string
-  /** Subagent identifier (e.g. "build", "fast_edit") */
-  subagent?: string
-  toolCallId?: string
-  toolName?: string
-  success?: boolean
-  result?: unknown
-  /** Set on chat_id events */
-  chatId?: string
-  /** Set on title_updated events */
-  title?: string
-  /** Set on error events */
-  error?: string
-  /** Set on content/reasoning events */
-  content?: string
-  /** Set on reasoning events */
-  phase?: string
-  /** UI metadata from copilot (title, icon, phaseLabel) */
-  ui?: Record<string, unknown>
-  /** Set on resource_added events */
-  resource?: { type: string; id: string; title: string }
-}
-
-export type ToolCallStatus =
-  | 'pending'
-  | 'executing'
-  | 'success'
-  | 'error'
-  | 'skipped'
-  | 'rejected'
-  | 'cancelled'
+export type LocalToolCallStatus = 'pending' | 'executing'
+export type ToolCallStatus = LocalToolCallStatus | MothershipStreamV1ToolOutcome
 
-const TERMINAL_TOOL_STATUSES: ReadonlySet<ToolCallStatus> = new Set([
-  'success',
-  'error',
-  'cancelled',
-  'skipped',
-  'rejected',
-])
+const TERMINAL_TOOL_STATUSES: ReadonlySet<ToolCallStatus> = new Set<MothershipStreamV1ToolOutcome>(
+  Object.values(MothershipStreamV1ToolOutcome)
+)
 
 export function isTerminalToolCallStatus(status?: string): boolean {
   return TERMINAL_TOOL_STATUSES.has(status as ToolCallStatus)
@@ -82,14 +27,18 @@ export interface ToolCallState {
   endTime?: number
 }
 
-export interface ToolCallResult<T = unknown> {
-  success: boolean
+export interface ToolCallResult<T = unknown> extends ToolExecutionResult {
   output?: T
-  error?: string
-  resources?: MothershipResource[]
 }
 
-export type ContentBlockType = 'text' | 'thinking' | 'tool_call' | 'subagent_text' | 'subagent'
+export const ContentBlockType = {
+  text: 'text',
+  thinking: 'thinking',
+  tool_call: 'tool_call',
+  subagent_text: 'subagent_text',
+  subagent: 'subagent',
+} as const
+export type ContentBlockType = (typeof ContentBlockType)[keyof typeof ContentBlockType]
 
 export interface ContentBlock {
   type: ContentBlockType
@@ -117,6 +66,11 @@ export interface StreamingContext {
     executionId?: string
     runId?: string
     pendingToolCallIds: string[]
+    frames?: Array<{
+      parentToolCallId: string
+      parentToolName: string
+      pendingToolIds: string[]
+    }>
   }
   currentThinkingBlock: ContentBlock | null
   isInThinkingBlock: boolean
@@ -130,6 +84,7 @@ export interface StreamingContext {
   errors: string[]
   usage?: { prompt: number; completion: number }
   cost?: { input: number; output: number; total: number }
+  trace: TraceCollector
 }
 
 export interface FileAttachment {
@@ -160,18 +115,10 @@ export interface OrchestratorRequest {
 export interface OrchestratorOptions {
   autoExecuteTools?: boolean
   timeout?: number
-  onEvent?: (event: SSEEvent) => void | Promise<void>
+  onEvent?: (event: StreamEvent) => void | Promise<void>
   onComplete?: (result: OrchestratorResult) => void | Promise<void>
   onError?: (error: Error) => void | Promise<void>
   abortSignal?: AbortSignal
-  /** Fires only on explicit user stop, never on passive transport disconnect. */
-  userStopSignal?: AbortSignal
-  /**
-   * Fires when the SSE client disconnects (tab close, navigation, etc.).
-   * Used to short-circuit `waitForToolCompletion` for client-executable tools
-   * so the orchestrator doesn't block for the full 60-min timeout.
-   */
-  clientDisconnectedSignal?: AbortSignal
   interactive?: boolean
 }
 
@@ -198,18 +145,6 @@ export interface ToolCallSummary {
   durationMs?: number
 }
 
-export interface ExecutionContext {
-  userId: string
-  workflowId: string
-  workspaceId?: string
-  chatId?: string
+export interface ExecutionContext extends ToolExecutionContext {
   messageId?: string
-  executionId?: string
-  runId?: string
-  abortSignal?: AbortSignal
-  /** Fires only on explicit user stop, never on passive transport disconnect. */
-  userStopSignal?: AbortSignal
-  userTimezone?: string
-  userPermission?: string
-  decryptedEnvVars?: Record<string, string>
 }
diff --git a/apps/sim/lib/copilot/resource-extraction.test.ts b/apps/sim/lib/copilot/resources/extraction.test.ts
similarity index 96%
rename from apps/sim/lib/copilot/resource-extraction.test.ts
rename to apps/sim/lib/copilot/resources/extraction.test.ts
index bb1b1677098..acf64688032 100644
--- a/apps/sim/lib/copilot/resource-extraction.test.ts
+++ b/apps/sim/lib/copilot/resources/extraction.test.ts
@@ -2,7 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { extractResourcesFromToolResult } from './resource-extraction'
+import { extractResourcesFromToolResult } from './extraction'
 
 describe('extractResourcesFromToolResult', () => {
   it('uses the knowledge base id for knowledge_base tag mutations', () => {
diff --git a/apps/sim/lib/copilot/resource-extraction.ts b/apps/sim/lib/copilot/resources/extraction.ts
similarity index 64%
rename from apps/sim/lib/copilot/resource-extraction.ts
rename to apps/sim/lib/copilot/resources/extraction.ts
index 9887ea5ded3..e1f8caff55f 100644
--- a/apps/sim/lib/copilot/resource-extraction.ts
+++ b/apps/sim/lib/copilot/resources/extraction.ts
@@ -1,96 +1,36 @@
-import type { MothershipResource, MothershipResourceType } from '@/lib/copilot/resource-types'
+import {
+  CreateWorkflow,
+  DeleteWorkflow,
+  DownloadToWorkspaceFile,
+  EditWorkflow,
+  FunctionExecute,
+  GenerateImage,
+  GenerateVisualization,
+  Knowledge,
+  KnowledgeBase,
+  UserTable,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import type { MothershipResource, MothershipResourceType } from './types'
 
 type ChatResource = MothershipResource
 type ResourceType = MothershipResourceType
 
-/**
- * Defines how each tool's result is surfaced in the resource panel:
- * - `dedicated` — opens its own resource tab (table, file, workflow, knowledgebase)
- * - `deferred`  — may open a dedicated tab; falls back to the Results tab if no resource is produced
- * - `excluded`  — hidden from the resource panel (internal tools, management, subagent wrappers)
- *
- * Any tool not listed here appears in the generic Results tab by default.
- */
-const TOOL_PANEL_BEHAVIOR: Record<string, 'dedicated' | 'deferred' | 'excluded'> = {
-  // Dedicated resource tab openers
-  user_table: 'dedicated',
-  workspace_file: 'dedicated',
-  download_to_workspace_file: 'dedicated',
-  create_workflow: 'dedicated',
-  edit_workflow: 'dedicated',
-  knowledge_base: 'dedicated',
-  knowledge: 'dedicated',
-  generate_visualization: 'dedicated',
-  generate_image: 'dedicated',
-  // Deferred: may produce a dedicated resource; falls back to Results tab otherwise
-  function_execute: 'deferred',
-  // Excluded: saves files without opening a resource tab
-  materialize_file: 'excluded',
-  // Excluded: internal / invisible
-  user_memory: 'excluded',
-  context_write: 'excluded',
-  context_compaction: 'excluded',
-  // Excluded: workflow and folder management
-  rename_workflow: 'excluded',
-  move_workflow: 'excluded',
-  delete_workflow: 'excluded',
-  create_folder: 'excluded',
-  delete_folder: 'excluded',
-  move_folder: 'excluded',
-  list_folders: 'excluded',
-  list_user_workspaces: 'excluded',
-  open_resource: 'excluded',
-  // Excluded: settings and credential management
-  set_environment_variables: 'excluded',
-  set_global_workflow_variables: 'excluded',
-  manage_mcp_tool: 'excluded',
-  manage_skill: 'excluded',
-  manage_credential: 'excluded',
-  manage_custom_tool: 'excluded',
-  oauth_get_auth_link: 'excluded',
-  oauth_request_access: 'excluded',
-  update_workspace_mcp_server: 'excluded',
-  delete_workspace_mcp_server: 'excluded',
-  create_workspace_mcp_server: 'excluded',
-  list_workspace_mcp_servers: 'excluded',
-  // Excluded: subagent wrappers — inner tools fire as individual events
-  build: 'excluded',
-  run: 'excluded',
-  deploy: 'excluded',
-  auth: 'excluded',
-  table: 'excluded',
-  job: 'excluded',
-  agent: 'excluded',
-  custom_tool: 'excluded',
-  research: 'excluded',
-  plan: 'excluded',
-  debug: 'excluded',
-  edit: 'excluded',
-  fast_edit: 'excluded',
-}
-
-/**
- * Returns true for resources that are client-only and must never be persisted to the server.
- * This covers the generic Results tab and the in-flight streaming-file preview.
- */
-export function isEphemeralResource(resource: { id: string; type: string }): boolean {
-  return resource.type === 'generic' || resource.id === 'streaming-file'
-}
+const RESOURCE_TOOL_NAMES: Set<string> = new Set([
+  UserTable.id,
+  WorkspaceFile.id,
+  DownloadToWorkspaceFile.id,
+  CreateWorkflow.id,
+  EditWorkflow.id,
+  FunctionExecute.id,
+  KnowledgeBase.id,
+  Knowledge.id,
+  GenerateVisualization.id,
+  GenerateImage.id,
+])
 
-/** Returns true for tools that open a dedicated resource tab or may fall back to the Results tab. */
 export function isResourceToolName(toolName: string): boolean {
-  const b = TOOL_PANEL_BEHAVIOR[toolName]
-  return b === 'dedicated' || b === 'deferred'
-}
-
-/** Returns true if the tool's result should appear in the Results tab at call time. */
-export function shouldOpenGenericResource(toolName: string): boolean {
-  return !(toolName in TOOL_PANEL_BEHAVIOR)
-}
-
-/** Returns true for tools that may fall back to the Results tab at completion time. */
-export function isDeferredResourceTool(toolName: string): boolean {
-  return TOOL_PANEL_BEHAVIOR[toolName] === 'deferred'
+  return RESOURCE_TOOL_NAMES.has(toolName)
 }
 
 function asRecord(value: unknown): Record<string, unknown> {
@@ -102,6 +42,12 @@ function getOperation(params: Record<string, unknown> | undefined): string | und
   return (args.operation ?? params?.operation) as string | undefined
 }
 
+function getWorkspaceFileTarget(
+  params: Record<string, unknown> | undefined
+): Record<string, unknown> {
+  return asRecord(params?.target)
+}
+
 const READ_ONLY_TABLE_OPS = new Set(['get', 'get_schema', 'get_row', 'query_rows'])
 const READ_ONLY_KB_OPS = new Set(['get', 'query', 'list_tags', 'get_tag_usage'])
 const READ_ONLY_KNOWLEDGE_ACTIONS = new Set(['listed', 'queried'])
@@ -122,7 +68,7 @@ export function extractResourcesFromToolResult(
   const data = asRecord(result.data)
 
   switch (toolName) {
-    case 'user_table': {
+    case UserTable.id: {
       if (READ_ONLY_TABLE_OPS.has(getOperation(params) ?? '')) return []
 
       if (result.tableId) {
@@ -158,7 +104,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'workspace_file': {
+    case WorkspaceFile.id: {
       const file = asRecord(data.file)
       if (file.id) {
         return [{ type: 'file', id: file.id as string, title: (file.name as string) || 'File' }]
@@ -171,7 +117,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'function_execute': {
+    case FunctionExecute.id: {
       if (result.tableId) {
         return [
           {
@@ -193,9 +139,9 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'download_to_workspace_file':
-    case 'generate_visualization':
-    case 'generate_image': {
+    case DownloadToWorkspaceFile.id:
+    case GenerateVisualization.id:
+    case GenerateImage.id: {
       if (result.fileId) {
         return [
           {
@@ -208,8 +154,8 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'create_workflow':
-    case 'edit_workflow': {
+    case CreateWorkflow.id:
+    case EditWorkflow.id: {
       const workflowId =
         (result.workflowId as string) ??
         (data.workflowId as string) ??
@@ -225,7 +171,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'knowledge_base': {
+    case KnowledgeBase.id: {
       if (READ_ONLY_KB_OPS.has(getOperation(params) ?? '')) return []
 
       const args = asRecord(params?.args)
@@ -243,7 +189,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'knowledge': {
+    case Knowledge.id: {
       const action = data.action as string | undefined
       if (READ_ONLY_KNOWLEDGE_ACTIONS.has(action ?? '')) return []
 
@@ -269,10 +215,10 @@ export function extractResourcesFromToolResult(
 }
 
 const DELETE_CAPABLE_TOOL_RESOURCE_TYPE: Record<string, ResourceType> = {
-  delete_workflow: 'workflow',
-  workspace_file: 'file',
-  user_table: 'table',
-  knowledge_base: 'knowledgebase',
+  [DeleteWorkflow.id]: 'workflow',
+  [WorkspaceFile.id]: 'file',
+  [UserTable.id]: 'table',
+  [KnowledgeBase.id]: 'knowledgebase',
 }
 
 export function hasDeleteCapability(toolName: string): boolean {
@@ -298,7 +244,7 @@ export function extractDeletedResourcesFromToolResult(
   const operation = (args.operation ?? params?.operation) as string | undefined
 
   switch (toolName) {
-    case 'delete_workflow': {
+    case DeleteWorkflow.id: {
       const workflowId = (result.workflowId as string) ?? (params?.workflowId as string)
       if (workflowId && result.deleted) {
         return [
@@ -308,16 +254,17 @@ export function extractDeletedResourcesFromToolResult(
       return []
     }
 
-    case 'workspace_file': {
+    case WorkspaceFile.id: {
       if (operation !== 'delete') return []
-      const fileId = (data.id as string) ?? (args.fileId as string)
+      const target = getWorkspaceFileTarget(params)
+      const fileId = (data.id as string) ?? (target.fileId as string) ?? (args.fileId as string)
       if (fileId) {
         return [{ type: resourceType, id: fileId, title: (data.name as string) || 'File' }]
       }
       return []
     }
 
-    case 'user_table': {
+    case UserTable.id: {
       if (operation !== 'delete') return []
       const tableId = (args.tableId as string) ?? (params?.tableId as string)
       if (tableId) {
@@ -326,7 +273,7 @@ export function extractDeletedResourcesFromToolResult(
       return []
     }
 
-    case 'knowledge_base': {
+    case KnowledgeBase.id: {
       if (operation !== 'delete') return []
       const kbId = (data.id as string) ?? (args.knowledgeBaseId as string)
       if (kbId) {
diff --git a/apps/sim/lib/copilot/resources.ts b/apps/sim/lib/copilot/resources/persistence.ts
similarity index 81%
rename from apps/sim/lib/copilot/resources.ts
rename to apps/sim/lib/copilot/resources/persistence.ts
index 4a674c83119..62d22d9e30c 100644
--- a/apps/sim/lib/copilot/resources.ts
+++ b/apps/sim/lib/copilot/resources/persistence.ts
@@ -2,32 +2,32 @@ import { db } from '@sim/db'
 import { copilotChats } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq, sql } from 'drizzle-orm'
-import { isEphemeralResource } from '@/lib/copilot/resource-extraction'
-import type { MothershipResource } from '@/lib/copilot/resource-types'
+import type { MothershipResource } from './types'
 
 export {
   extractDeletedResourcesFromToolResult,
   extractResourcesFromToolResult,
   hasDeleteCapability,
-  isEphemeralResource,
   isResourceToolName,
-} from '@/lib/copilot/resource-extraction'
+} from './extraction'
 export type {
   MothershipResource as ChatResource,
   MothershipResourceType as ResourceType,
-} from '@/lib/copilot/resource-types'
+} from './types'
 
 const logger = createLogger('CopilotResources')
 
+type ChatResource = MothershipResource
+
 /**
  * Appends resources to a chat's JSONB resources column, deduplicating by type+id.
  * Updates the title of existing resources if the new title is more specific.
  */
 export async function persistChatResources(
   chatId: string,
-  newResources: MothershipResource[]
+  newResources: ChatResource[]
 ): Promise<void> {
-  const toMerge = newResources.filter((r) => !isEphemeralResource(r))
+  const toMerge = newResources.filter((r) => r.id !== 'streaming-file')
   if (toMerge.length === 0) return
 
   try {
@@ -39,8 +39,8 @@ export async function persistChatResources(
 
     if (!chat) return
 
-    const existing = Array.isArray(chat.resources) ? (chat.resources as MothershipResource[]) : []
-    const map = new Map<string, MothershipResource>()
+    const existing = Array.isArray(chat.resources) ? (chat.resources as ChatResource[]) : []
+    const map = new Map<string, ChatResource>()
     const GENERIC = new Set(['Table', 'File', 'Workflow', 'Knowledge Base', 'Folder'])
 
     for (const r of existing) {
@@ -72,10 +72,7 @@ export async function persistChatResources(
 /**
  * Removes resources from a chat's JSONB resources column by type+id.
  */
-export async function removeChatResources(
-  chatId: string,
-  toRemove: MothershipResource[]
-): Promise<void> {
+export async function removeChatResources(chatId: string, toRemove: ChatResource[]): Promise<void> {
   if (toRemove.length === 0) return
 
   try {
@@ -87,7 +84,7 @@ export async function removeChatResources(
 
     if (!chat) return
 
-    const existing = Array.isArray(chat.resources) ? (chat.resources as MothershipResource[]) : []
+    const existing = Array.isArray(chat.resources) ? (chat.resources as ChatResource[]) : []
     const removeKeys = new Set(toRemove.map((r) => `${r.type}:${r.id}`))
     const filtered = existing.filter((r) => !removeKeys.has(`${r.type}:${r.id}`))
 
diff --git a/apps/sim/lib/copilot/resources/types.ts b/apps/sim/lib/copilot/resources/types.ts
new file mode 100644
index 00000000000..211182dc82b
--- /dev/null
+++ b/apps/sim/lib/copilot/resources/types.ts
@@ -0,0 +1,29 @@
+export const MothershipResourceType = {
+  table: 'table',
+  file: 'file',
+  workflow: 'workflow',
+  knowledgebase: 'knowledgebase',
+  folder: 'folder',
+  task: 'task',
+  generic: 'generic',
+} as const
+export type MothershipResourceType =
+  (typeof MothershipResourceType)[keyof typeof MothershipResourceType]
+
+export interface MothershipResource {
+  type: MothershipResourceType
+  id: string
+  title: string
+}
+
+export function isEphemeralResource(resource: MothershipResource): boolean {
+  return resource.type === 'generic' || resource.id === 'streaming-file'
+}
+
+export const VFS_DIR_TO_RESOURCE: Record<string, MothershipResourceType> = {
+  tables: 'table',
+  files: 'file',
+  workflows: 'workflow',
+  knowledgebases: 'knowledgebase',
+  folders: 'folder',
+} as const
diff --git a/apps/sim/lib/copilot/task-events.ts b/apps/sim/lib/copilot/tasks.ts
similarity index 95%
rename from apps/sim/lib/copilot/task-events.ts
rename to apps/sim/lib/copilot/tasks.ts
index 50653809bf4..5828a711cb4 100644
--- a/apps/sim/lib/copilot/task-events.ts
+++ b/apps/sim/lib/copilot/tasks.ts
@@ -9,7 +9,7 @@
 
 import { createPubSubChannel } from '@/lib/events/pubsub'
 
-export interface TaskStatusEvent {
+interface TaskStatusEvent {
   workspaceId: string
   chatId: string
   type: 'started' | 'completed' | 'created' | 'deleted' | 'renamed'
diff --git a/apps/sim/lib/copilot/tool-executor/executor.test.ts b/apps/sim/lib/copilot/tool-executor/executor.test.ts
new file mode 100644
index 00000000000..4ae97dd45c7
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/executor.test.ts
@@ -0,0 +1,61 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { isKnownTool, isSimExecuted } = vi.hoisted(() => ({
+  isKnownTool: vi.fn(),
+  isSimExecuted: vi.fn(),
+}))
+
+const { executeAppTool } = vi.hoisted(() => ({
+  executeAppTool: vi.fn(),
+}))
+
+vi.mock('./router', () => ({
+  isKnownTool,
+  isSimExecuted,
+}))
+
+vi.mock('@/tools', () => ({
+  executeTool: executeAppTool,
+}))
+
+import { executeTool } from './executor'
+
+describe('copilot tool executor fallback', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('falls back to app tool executor for dynamic sim tools', async () => {
+    isKnownTool.mockReturnValue(false)
+    isSimExecuted.mockReturnValue(false)
+    executeAppTool.mockResolvedValue({ success: true, output: { emails: [] } })
+
+    const result = await executeTool(
+      'gmail_read',
+      { maxResults: 10, credentialId: 'cred-123' },
+      { userId: 'user-1', workflowId: 'workflow-1', workspaceId: 'ws-1', chatId: 'chat-1' }
+    )
+
+    expect(executeAppTool).toHaveBeenCalledWith(
+      'gmail_read',
+      expect.objectContaining({
+        maxResults: 10,
+        credentialId: 'cred-123',
+        credential: 'cred-123',
+        _context: expect.objectContaining({
+          userId: 'user-1',
+          workflowId: 'workflow-1',
+          workspaceId: 'ws-1',
+          chatId: 'chat-1',
+          enforceCredentialAccess: true,
+        }),
+      }),
+      false
+    )
+    expect(result).toEqual({ success: true, output: { emails: [] } })
+  })
+})
diff --git a/apps/sim/lib/copilot/tool-executor/executor.ts b/apps/sim/lib/copilot/tool-executor/executor.ts
new file mode 100644
index 00000000000..734246e16fd
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/executor.ts
@@ -0,0 +1,112 @@
+import { createLogger } from '@sim/logger'
+import { executeTool as executeAppTool } from '@/tools'
+import { isKnownTool, isSimExecuted } from './router'
+import type {
+  ToolCallDescriptor,
+  ToolExecutionContext,
+  ToolExecutionResult,
+  ToolHandler,
+} from './types'
+
+const logger = createLogger('ToolExecutor')
+
+const handlerRegistry = new Map<string, ToolHandler>()
+
+export function registerHandler(toolId: string, handler: ToolHandler): void {
+  handlerRegistry.set(toolId, handler)
+}
+
+export function registerHandlers(entries: Record<string, ToolHandler>): void {
+  for (const [toolId, handler] of Object.entries(entries)) {
+    handlerRegistry.set(toolId, handler)
+  }
+}
+
+export function getRegisteredToolIds(): string[] {
+  return Array.from(handlerRegistry.keys())
+}
+
+export function hasHandler(toolId: string): boolean {
+  return handlerRegistry.has(toolId)
+}
+
+export async function executeTool(
+  toolId: string,
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+): Promise<ToolExecutionResult> {
+  const canUseRegisteredHandler = isKnownTool(toolId) && isSimExecuted(toolId)
+  if (!canUseRegisteredHandler) {
+    const appParams = buildAppToolParams(params, context)
+    return executeAppTool(toolId, appParams, false)
+  }
+
+  if (context.abortSignal?.aborted) {
+    return { success: false, error: 'Execution aborted' }
+  }
+
+  const handler = handlerRegistry.get(toolId)
+  if (!handler) {
+    logger.warn('No handler registered for tool', { toolId })
+    return { success: false, error: `No handler for tool: ${toolId}` }
+  }
+
+  try {
+    return await handler(params, context)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logger.error('Tool execution failed', { toolId, error: message })
+    return { success: false, error: message }
+  }
+}
+
+export async function executeToolBatch(
+  toolCalls: ToolCallDescriptor[],
+  context: ToolExecutionContext
+): Promise<Map<string, ToolExecutionResult>> {
+  const results = new Map<string, ToolExecutionResult>()
+
+  const executions = toolCalls.map(async ({ toolCallId, toolId, params }) => {
+    const result = await executeTool(toolId, params, context)
+    results.set(toolCallId, result)
+  })
+
+  await Promise.allSettled(executions)
+
+  for (const { toolCallId } of toolCalls) {
+    if (!results.has(toolCallId)) {
+      results.set(toolCallId, {
+        success: false,
+        error: 'Tool execution did not produce a result',
+      })
+    }
+  }
+
+  return results
+}
+
+function buildAppToolParams(
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+): Record<string, unknown> {
+  const result = { ...params }
+
+  if (result.credentialId && !result.credential && !result.oauthCredential) {
+    result.credential = result.credentialId
+  }
+
+  result._context = {
+    ...(typeof result._context === 'object' && result._context !== null
+      ? (result._context as object)
+      : {}),
+    userId: context.userId,
+    workflowId: context.workflowId,
+    workspaceId: context.workspaceId,
+    chatId: context.chatId,
+    executionId: context.executionId,
+    runId: context.runId,
+    enforceCredentialAccess: true,
+  }
+
+  return result
+}
diff --git a/apps/sim/lib/copilot/tool-executor/index.ts b/apps/sim/lib/copilot/tool-executor/index.ts
new file mode 100644
index 00000000000..8bec66e812f
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/index.ts
@@ -0,0 +1,25 @@
+export {
+  executeTool,
+  executeToolBatch,
+  getRegisteredToolIds,
+  hasHandler,
+  registerHandler,
+  registerHandlers,
+} from './executor'
+export { ensureHandlersRegistered } from './register-handlers'
+export {
+  getToolEntry,
+  isGoExecuted,
+  isKnownTool,
+  isSimExecuted,
+  type PartitionedBatch,
+  partitionToolBatch,
+  routeToolCall,
+  type ToolRoute,
+} from './router'
+export type {
+  ToolCallDescriptor,
+  ToolExecutionContext,
+  ToolExecutionResult,
+  ToolHandler,
+} from './types'
diff --git a/apps/sim/lib/copilot/tool-executor/register-handlers.ts b/apps/sim/lib/copilot/tool-executor/register-handlers.ts
new file mode 100644
index 00000000000..4ee4debeb97
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/register-handlers.ts
@@ -0,0 +1,194 @@
+import { createLogger } from '@sim/logger'
+import {
+  CheckDeploymentStatus,
+  CompleteJob,
+  CreateFolder,
+  CreateJob,
+  CreateWorkflow,
+  CreateWorkspaceMcpServer,
+  DeleteFolder,
+  DeleteWorkflow,
+  DeleteWorkspaceMcpServer,
+  DeployApi,
+  DeployChat,
+  DeployMcp,
+  FunctionExecute,
+  GenerateApiKey,
+  GetBlockOutputs,
+  GetBlockUpstreamReferences,
+  GetDeployedWorkflowState,
+  GetDeploymentVersion,
+  GetPlatformActions,
+  GetWorkflowData,
+  Glob as GlobTool,
+  Grep as GrepTool,
+  ListFolders,
+  ListUserWorkspaces,
+  ListWorkspaceMcpServers,
+  ManageCredential,
+  ManageCustomTool,
+  ManageJob,
+  ManageMcpTool,
+  ManageSkill,
+  MaterializeFile,
+  MoveFolder,
+  MoveWorkflow,
+  OauthGetAuthLink,
+  OauthRequestAccess,
+  OpenResource,
+  Read as ReadTool,
+  Redeploy,
+  RenameWorkflow,
+  RevertToVersion,
+  RunBlock,
+  RunFromBlock,
+  RunWorkflow,
+  RunWorkflowUntilBlock,
+  SetGlobalWorkflowVariables,
+  UpdateJobHistory,
+  UpdateWorkspaceMcpServer,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import { createServerToolHandler } from '@/lib/copilot/tools/registry/server-tool-adapter'
+import { getRegisteredServerToolNames } from '@/lib/copilot/tools/server/router'
+import {
+  executeDeployApi,
+  executeDeployChat,
+  executeDeployMcp,
+  executeRedeploy,
+} from '../tools/handlers/deployment/deploy'
+import {
+  executeCheckDeploymentStatus,
+  executeCreateWorkspaceMcpServer,
+  executeDeleteWorkspaceMcpServer,
+  executeGetDeploymentVersion,
+  executeListWorkspaceMcpServers,
+  executeRevertToVersion,
+  executeUpdateWorkspaceMcpServer,
+} from '../tools/handlers/deployment/manage'
+import { executeFunctionExecute } from '../tools/handlers/function-execute'
+import {
+  executeCompleteJob,
+  executeCreateJob,
+  executeManageJob,
+  executeUpdateJobHistory,
+} from '../tools/handlers/jobs'
+import { executeManageCredential } from '../tools/handlers/management/manage-credential'
+import { executeManageCustomTool } from '../tools/handlers/management/manage-custom-tool'
+import { executeManageMcpTool } from '../tools/handlers/management/manage-mcp-tool'
+import { executeManageSkill } from '../tools/handlers/management/manage-skill'
+import { executeMaterializeFile } from '../tools/handlers/materialize-file'
+import { executeOAuthGetAuthLink, executeOAuthRequestAccess } from '../tools/handlers/oauth'
+import { executeGetPlatformActions } from '../tools/handlers/platform'
+import { executeOpenResource } from '../tools/handlers/resources'
+import { executeVfsGlob, executeVfsGrep, executeVfsRead } from '../tools/handlers/vfs'
+import {
+  executeCreateFolder,
+  executeCreateWorkflow,
+  executeDeleteFolder,
+  executeDeleteWorkflow,
+  executeGenerateApiKey,
+  executeMoveFolder,
+  executeMoveWorkflow,
+  executeRenameWorkflow,
+  executeRunBlock,
+  executeRunFromBlock,
+  executeRunWorkflow,
+  executeRunWorkflowUntilBlock,
+  executeSetGlobalWorkflowVariables,
+} from '../tools/handlers/workflow/mutations'
+import {
+  executeGetBlockOutputs,
+  executeGetBlockUpstreamReferences,
+  executeGetDeployedWorkflowState,
+  executeGetWorkflowData,
+  executeListFolders,
+  executeListUserWorkspaces,
+} from '../tools/handlers/workflow/queries'
+import { registerHandlers } from './executor'
+import type { ToolHandler } from './types'
+
+const logger = createLogger('ToolHandlerRegistration')
+
+let registered = false
+
+export function ensureHandlersRegistered(): void {
+  if (registered) return
+  registered = true
+  registerHandlers(buildHandlerMap())
+  logger.info('Tool handlers registered')
+}
+
+// Bridge: handler implementations accept specific param types (e.g. CreateWorkflowParams)
+// while ToolHandler accepts Record<string, unknown>. The params are cast internally by
+// each implementation. ExecutionContext extends ToolExecutionContext so context is compatible.
+function h(fn: (params: any, context: any) => Promise<any>): ToolHandler {
+  return fn as ToolHandler
+}
+
+function buildHandlerMap(): Record<string, ToolHandler> {
+  return {
+    [ListUserWorkspaces.id]: h((_p, c) => executeListUserWorkspaces(c)),
+    [ListFolders.id]: h(executeListFolders),
+    [GetWorkflowData.id]: h(executeGetWorkflowData),
+    [GetBlockOutputs.id]: h(executeGetBlockOutputs),
+    [GetBlockUpstreamReferences.id]: h(executeGetBlockUpstreamReferences),
+    [GetDeployedWorkflowState.id]: h(executeGetDeployedWorkflowState),
+
+    [CreateWorkflow.id]: h(executeCreateWorkflow),
+    [CreateFolder.id]: h(executeCreateFolder),
+    [DeleteWorkflow.id]: h(executeDeleteWorkflow),
+    [DeleteFolder.id]: h(executeDeleteFolder),
+    [RenameWorkflow.id]: h(executeRenameWorkflow),
+    [MoveWorkflow.id]: h(executeMoveWorkflow),
+    [MoveFolder.id]: h(executeMoveFolder),
+    [RunWorkflow.id]: h(executeRunWorkflow),
+    [RunWorkflowUntilBlock.id]: h(executeRunWorkflowUntilBlock),
+    [RunFromBlock.id]: h(executeRunFromBlock),
+    [RunBlock.id]: h(executeRunBlock),
+    [GenerateApiKey.id]: h(executeGenerateApiKey),
+    [SetGlobalWorkflowVariables.id]: h(executeSetGlobalWorkflowVariables),
+
+    [DeployApi.id]: h(executeDeployApi),
+    [DeployChat.id]: h(executeDeployChat),
+    [DeployMcp.id]: h(executeDeployMcp),
+    [Redeploy.id]: h(executeRedeploy),
+    [CheckDeploymentStatus.id]: h(executeCheckDeploymentStatus),
+    [ListWorkspaceMcpServers.id]: h(executeListWorkspaceMcpServers),
+    [CreateWorkspaceMcpServer.id]: h(executeCreateWorkspaceMcpServer),
+    [UpdateWorkspaceMcpServer.id]: h(executeUpdateWorkspaceMcpServer),
+    [DeleteWorkspaceMcpServer.id]: h(executeDeleteWorkspaceMcpServer),
+    [GetDeploymentVersion.id]: h(executeGetDeploymentVersion),
+    [RevertToVersion.id]: h(executeRevertToVersion),
+
+    [CreateJob.id]: h(executeCreateJob),
+    [ManageJob.id]: h(executeManageJob),
+    [CompleteJob.id]: h(executeCompleteJob),
+    [UpdateJobHistory.id]: h(executeUpdateJobHistory),
+
+    [GrepTool.id]: h(executeVfsGrep),
+    [GlobTool.id]: h(executeVfsGlob),
+    [ReadTool.id]: h(executeVfsRead),
+
+    [ManageCustomTool.id]: h(executeManageCustomTool),
+    [ManageMcpTool.id]: h(executeManageMcpTool),
+    [ManageSkill.id]: h(executeManageSkill),
+    [ManageCredential.id]: h(executeManageCredential),
+    [OauthGetAuthLink.id]: h(executeOAuthGetAuthLink),
+    [OauthRequestAccess.id]: h(executeOAuthRequestAccess),
+    [OpenResource.id]: h(executeOpenResource),
+    [GetPlatformActions.id]: h(executeGetPlatformActions),
+    [MaterializeFile.id]: h(executeMaterializeFile),
+    [FunctionExecute.id]: h(executeFunctionExecute),
+
+    ...buildServerToolHandlers(),
+  }
+}
+
+function buildServerToolHandlers(): Record<string, ToolHandler> {
+  const toolNames = getRegisteredServerToolNames()
+  const handlers: Record<string, ToolHandler> = {}
+  for (const toolId of toolNames) {
+    handlers[toolId] = createServerToolHandler(toolId)
+  }
+  return handlers
+}
diff --git a/apps/sim/lib/copilot/tool-executor/router.ts b/apps/sim/lib/copilot/tool-executor/router.ts
new file mode 100644
index 00000000000..18202762d66
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/router.ts
@@ -0,0 +1,59 @@
+import { TOOL_CATALOG, type ToolCatalogEntry } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { ToolCallDescriptor } from './types'
+
+export type ToolExecutor = ToolCatalogEntry['executor']
+
+export function isToolInCatalog(toolId: string): boolean {
+  return toolId in TOOL_CATALOG
+}
+
+export function getToolEntry(toolId: string): ToolCatalogEntry | undefined {
+  return TOOL_CATALOG[toolId]
+}
+
+export type ToolRoute = {
+  executor: ToolExecutor
+  mode: ToolCatalogEntry['mode']
+  subagentId?: string
+}
+
+export function routeToolCall(toolId: string): ToolRoute | null {
+  const entry = getToolEntry(toolId)
+  if (!entry) return null
+  return { executor: entry.executor, mode: entry.mode, subagentId: entry.subagentId }
+}
+
+export function isSimExecuted(toolId: string): boolean {
+  return getToolEntry(toolId)?.executor === 'sim'
+}
+
+export function isGoExecuted(toolId: string): boolean {
+  return getToolEntry(toolId)?.executor === 'go'
+}
+
+export function isKnownTool(toolId: string): boolean {
+  return isToolInCatalog(toolId)
+}
+
+export interface PartitionedBatch {
+  sim: ToolCallDescriptor[]
+  go: ToolCallDescriptor[]
+  subagent: ToolCallDescriptor[]
+  client: ToolCallDescriptor[]
+  unknown: ToolCallDescriptor[]
+}
+
+export function partitionToolBatch(toolCalls: ToolCallDescriptor[]): PartitionedBatch {
+  const result: PartitionedBatch = { sim: [], go: [], subagent: [], client: [], unknown: [] }
+
+  for (const tc of toolCalls) {
+    const route = routeToolCall(tc.toolId)
+    if (!route) {
+      result.unknown.push(tc)
+      continue
+    }
+    result[route.executor].push(tc)
+  }
+
+  return result
+}
diff --git a/apps/sim/lib/copilot/tool-executor/types.ts b/apps/sim/lib/copilot/tool-executor/types.ts
new file mode 100644
index 00000000000..60ecda8db45
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/types.ts
@@ -0,0 +1,32 @@
+import type { MothershipResource } from '@/lib/copilot/resources/types'
+
+export interface ToolExecutionContext {
+  userId: string
+  workflowId: string
+  workspaceId?: string
+  chatId?: string
+  executionId?: string
+  runId?: string
+  abortSignal?: AbortSignal
+  userTimezone?: string
+  userPermission?: string
+  decryptedEnvVars?: Record<string, string>
+}
+
+export interface ToolExecutionResult {
+  success: boolean
+  output?: unknown
+  error?: string
+  resources?: MothershipResource[]
+}
+
+export type ToolHandler = (
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+) => Promise<ToolExecutionResult>
+
+export interface ToolCallDescriptor {
+  toolCallId: string
+  toolId: string
+  params: Record<string, unknown>
+}
diff --git a/apps/sim/lib/copilot/client-sse/run-tool-execution.test.ts b/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
similarity index 100%
rename from apps/sim/lib/copilot/client-sse/run-tool-execution.test.ts
rename to apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
diff --git a/apps/sim/lib/copilot/client-sse/run-tool-execution.ts b/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
similarity index 86%
rename from apps/sim/lib/copilot/client-sse/run-tool-execution.ts
rename to apps/sim/lib/copilot/tools/client/run-tool-execution.ts
index 2e22fcf6a78..66f1369d186 100644
--- a/apps/sim/lib/copilot/client-sse/run-tool-execution.ts
+++ b/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
@@ -1,5 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { COPILOT_CONFIRM_API_PATH } from '@/lib/copilot/constants'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  RunBlock,
+  RunFromBlock,
+  RunWorkflowUntilBlock,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
 import { generateId } from '@/lib/core/utils/uuid'
 import { executeWorkflowWithFullLogging } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils'
@@ -50,6 +56,13 @@ export function markRunToolManuallyStopped(workflowId: string): string | null {
   return toolCallId
 }
 
+export function isRunToolActiveForId(toolCallId: string): boolean {
+  for (const activeId of activeRunToolByWorkflowId.values()) {
+    if (activeId === toolCallId) return true
+  }
+  return false
+}
+
 export function cancelRunToolExecution(workflowId: string): void {
   const controller = activeRunAbortByWorkflowId.get(workflowId)
   if (!controller) return
@@ -76,7 +89,7 @@ export async function reportManualRunToolStop(
 
   await reportCompletion(
     toolCallId,
-    'cancelled',
+    MothershipStreamV1ToolOutcome.cancelled,
     'Workflow execution was stopped manually by the user.',
     {
       reason: 'user_cancelled',
@@ -100,7 +113,26 @@ async function doExecuteRunTool(
   if (!targetWorkflowId) {
     logger.warn('[RunTool] Execution prevented: no active workflow', { toolCallId, toolName })
     setToolState(toolCallId, ClientToolCallState.error)
-    await reportCompletion(toolCallId, 'error', 'No active workflow found')
+    await reportCompletion(
+      toolCallId,
+      MothershipStreamV1ToolOutcome.error,
+      'No active workflow found'
+    )
+    return
+  }
+
+  const existingToolCallId = activeRunToolByWorkflowId.get(targetWorkflowId)
+  if (existingToolCallId) {
+    logger.warn('[RunTool] Execution prevented: another run tool is already active', {
+      toolCallId,
+      toolName,
+      existingToolCallId,
+    })
+    await reportCompletion(
+      toolCallId,
+      MothershipStreamV1ToolOutcome.error,
+      'Workflow is already being executed by another tool. Wait for it to complete.'
+    )
     return
   }
 
@@ -112,8 +144,13 @@ async function doExecuteRunTool(
 
   if (isExecuting) {
     logger.warn('[RunTool] Execution prevented: already executing', { toolCallId, toolName })
+    activeRunToolByWorkflowId.delete(targetWorkflowId)
     setToolState(toolCallId, ClientToolCallState.error)
-    await reportCompletion(toolCallId, 'error', 'Workflow is already executing. Try again later')
+    await reportCompletion(
+      toolCallId,
+      MothershipStreamV1ToolOutcome.error,
+      'Workflow is already executing. Try again later'
+    )
     return
   }
 
@@ -123,20 +160,19 @@ async function doExecuteRunTool(
     | undefined
 
   const stopAfterBlockId = (() => {
-    if (toolName === 'run_workflow_until_block')
-      return params.stopAfterBlockId as string | undefined
-    if (toolName === 'run_block') return params.blockId as string | undefined
+    if (toolName === RunWorkflowUntilBlock.id) return params.stopAfterBlockId as string | undefined
+    if (toolName === RunBlock.id) return params.blockId as string | undefined
     return undefined
   })()
 
   const runFromBlock = (() => {
-    if (toolName === 'run_from_block' && params.startBlockId) {
+    if (toolName === RunFromBlock.id && params.startBlockId) {
       return {
         startBlockId: params.startBlockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',
       }
     }
-    if (toolName === 'run_block' && params.blockId) {
+    if (toolName === RunBlock.id && params.blockId) {
       return {
         startBlockId: params.blockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',
@@ -230,7 +266,7 @@ async function doExecuteRunTool(
       setToolState(toolCallId, ClientToolCallState.success)
       await reportCompletion(
         toolCallId,
-        'success',
+        MothershipStreamV1ToolOutcome.success,
         `Workflow execution completed. Started at: ${executionStartTime}`,
         buildResultData(result)
       )
@@ -238,7 +274,12 @@ async function doExecuteRunTool(
       const msg = errorMessage || 'Workflow execution failed'
       logger.error('[RunTool] Workflow execution failed', { toolCallId, toolName, error: msg })
       setToolState(toolCallId, ClientToolCallState.error)
-      await reportCompletion(toolCallId, 'error', msg, buildResultData(result))
+      await reportCompletion(
+        toolCallId,
+        MothershipStreamV1ToolOutcome.error,
+        msg,
+        buildResultData(result)
+      )
     }
   } catch (err) {
     if (manuallyStoppedToolCallIds.has(toolCallId)) {
@@ -250,7 +291,7 @@ async function doExecuteRunTool(
       const msg = err instanceof Error ? err.message : String(err)
       logger.error('[RunTool] Workflow execution threw', { toolCallId, toolName, error: msg })
       setToolState(toolCallId, ClientToolCallState.error)
-      await reportCompletion(toolCallId, 'error', msg)
+      await reportCompletion(toolCallId, MothershipStreamV1ToolOutcome.error, msg)
     }
   } finally {
     if (typeof window !== 'undefined') {
@@ -315,7 +356,7 @@ function buildResultData(result: unknown): Record<string, unknown> | undefined {
  */
 async function reportCompletion(
   toolCallId: string,
-  status: 'success' | 'error' | 'cancelled',
+  status: MothershipStreamV1ToolOutcome,
   message?: string,
   data?: Record<string, unknown>
 ): Promise<void> {
@@ -331,9 +372,6 @@ async function reportCompletion(
       headers: { 'Content-Type': 'application/json' },
       body,
     })
-    // Next.js silently truncates request bodies beyond its body size limit (default 10MB),
-    // corrupting the JSON and causing a server-side parse error (500). When the request fails
-    // and the payload is large, retry without logs (the largest field) to fit under the limit.
     const LARGE_PAYLOAD_THRESHOLD = 10 * 1024 * 1024
     const bodySize = new Blob([body]).size
     if (!res.ok && data && bodySize > LARGE_PAYLOAD_THRESHOLD) {
diff --git a/apps/sim/lib/copilot/store-utils.ts b/apps/sim/lib/copilot/tools/client/store-utils.ts
similarity index 89%
rename from apps/sim/lib/copilot/store-utils.ts
rename to apps/sim/lib/copilot/tools/client/store-utils.ts
index 9447f9cbf11..a050b8cf235 100644
--- a/apps/sim/lib/copilot/store-utils.ts
+++ b/apps/sim/lib/copilot/tools/client/store-utils.ts
@@ -23,7 +23,8 @@ import {
   Wrench,
   Zap,
 } from 'lucide-react'
-import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resource-types'
+import { Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
 import {
   ClientToolCallState,
   type ClientToolDisplay,
@@ -133,7 +134,7 @@ function specialToolDisplay(
     }
   }
 
-  if (toolName === 'read') {
+  if (toolName === ReadTool.id) {
     const target = describeReadTarget(readStringParam(params, 'path'))
     return {
       text: formatReadingLabel(target, state),
@@ -227,7 +228,7 @@ function serverUIFallback(serverUI: ServerToolUI, state: ClientToolCallState): C
   }
 }
 
-export function humanizedFallback(
+function humanizedFallback(
   toolName: string,
   state: ClientToolCallState
 ): ClientToolDisplay | undefined {
@@ -244,7 +245,7 @@ export function humanizedFallback(
 }
 
 export function isRejectedState(state: string): boolean {
-  return state === 'rejected'
+  return state === ClientToolCallState.rejected
 }
 
 export function isReviewState(state: string): boolean {
@@ -254,24 +255,3 @@ export function isReviewState(state: string): boolean {
 export function isBackgroundState(state: string): boolean {
   return state === 'background'
 }
-
-export function isTerminalState(state: string): boolean {
-  return (
-    state === ClientToolCallState.success ||
-    state === ClientToolCallState.error ||
-    state === ClientToolCallState.rejected ||
-    state === ClientToolCallState.aborted ||
-    isReviewState(state) ||
-    isBackgroundState(state)
-  )
-}
-
-export function stripTodoTags(text: string): string {
-  if (!text) return text
-  return text
-    .replace(/<marktodo>[\s\S]*?<\/marktodo>/g, '')
-    .replace(/<checkofftodo>[\s\S]*?<\/checkofftodo>/g, '')
-    .replace(/<design_workflow>[\s\S]*?<\/design_workflow>/g, '')
-    .replace(/[ \t]+\n/g, '\n')
-    .replace(/\n{2,}/g, '\n')
-}
diff --git a/apps/sim/lib/copilot/tools/client/tool-display-registry.ts b/apps/sim/lib/copilot/tools/client/tool-display-registry.ts
index cad83d1ec4c..29a600657b3 100644
--- a/apps/sim/lib/copilot/tools/client/tool-display-registry.ts
+++ b/apps/sim/lib/copilot/tools/client/tool-display-registry.ts
@@ -4,7 +4,6 @@ import {
   Bug,
   Check,
   CheckCircle,
-  ClipboardList,
   Database,
   Eye,
   FileSearch,
@@ -12,7 +11,6 @@ import {
   FolderPlus,
   GitBranch,
   Globe,
-  Globe2,
   Grid2x2,
   Grid2x2Check,
   Grid2x2X,
@@ -372,20 +370,20 @@ const META_manage_skill: ToolMetadata = {
   },
 }
 
-const META_build: ToolMetadata = {
+const META_workflow: ToolMetadata = {
   displayNames: {
-    [ClientToolCallState.generating]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Built', icon: Wrench },
-    [ClientToolCallState.error]: { text: 'Failed to build', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped build', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted build', icon: XCircle },
+    [ClientToolCallState.generating]: { text: 'Managing workflow', icon: Loader2 },
+    [ClientToolCallState.pending]: { text: 'Managing workflow', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Managing workflow', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Done', icon: Wrench },
+    [ClientToolCallState.error]: { text: 'Failed', icon: XCircle },
+    [ClientToolCallState.rejected]: { text: 'Skipped', icon: XCircle },
+    [ClientToolCallState.aborted]: { text: 'Aborted', icon: XCircle },
   },
   uiConfig: {
     subagent: {
-      streamingLabel: 'Building',
-      completedLabel: 'Built',
+      streamingLabel: 'Managing workflow',
+      completedLabel: 'Done',
       shouldCollapse: true,
       outputArtifacts: [],
     },
@@ -961,71 +959,6 @@ const META_list_workspace_mcp_servers: ToolMetadata = {
   interrupt: undefined,
 }
 
-const META_make_api_request: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Preparing API request', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Review API request', icon: Globe2 },
-    [ClientToolCallState.executing]: { text: 'Executing API request', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Completed API request', icon: Globe2 },
-    [ClientToolCallState.error]: { text: 'Failed to execute API request', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped API request', icon: MinusCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted API request', icon: XCircle },
-  },
-  interrupt: {
-    accept: { text: 'Execute', icon: Globe2 },
-    reject: { text: 'Skip', icon: MinusCircle },
-  },
-  uiConfig: {
-    interrupt: {
-      accept: { text: 'Execute', icon: Globe2 },
-      reject: { text: 'Skip', icon: MinusCircle },
-      showAllowOnce: true,
-      showAllowAlways: true,
-    },
-    paramsTable: {
-      columns: [
-        { key: 'method', label: 'Method', width: '26%', editable: true, mono: true },
-        { key: 'url', label: 'Endpoint', width: '74%', editable: true, mono: true },
-      ],
-      extractRows: (params: Record<string, any>): Array<[string, ...any[]]> => {
-        return [['request', (params.method || 'GET').toUpperCase(), params.url || '']]
-      },
-    },
-  },
-  getDynamicText: (params, state) => {
-    if (params?.url && typeof params.url === 'string') {
-      const method = params.method || 'GET'
-      let url = params.url
-
-      // Extract domain from URL for cleaner display
-      try {
-        const urlObj = new URL(url)
-        url = urlObj.hostname + urlObj.pathname
-      } catch {
-        // Use URL as-is if parsing fails
-      }
-
-      switch (state) {
-        case ClientToolCallState.success:
-          return `${method} ${url} complete`
-        case ClientToolCallState.executing:
-          return `${method} ${url}`
-        case ClientToolCallState.generating:
-          return `Preparing ${method} ${url}`
-        case ClientToolCallState.pending:
-          return `Review ${method} ${url}`
-        case ClientToolCallState.error:
-          return `Failed ${method} ${url}`
-        case ClientToolCallState.rejected:
-          return `Skipped ${method} ${url}`
-        case ClientToolCallState.aborted:
-          return `Aborted ${method} ${url}`
-      }
-    }
-    return undefined
-  },
-}
-
 const META_manage_custom_tool: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: {
@@ -2087,66 +2020,6 @@ const META_superagent: ToolMetadata = {
   },
 }
 
-const META_plan: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Planning', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Planning', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Planning', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Planned', icon: ClipboardList },
-    [ClientToolCallState.error]: { text: 'Failed to plan', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped planning', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted planning', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Planning',
-      completedLabel: 'Planned',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
-const META_edit: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Editing', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Editing', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Editing', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Edited', icon: PencilLine },
-    [ClientToolCallState.error]: { text: 'Failed to edit', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped editing', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted editing', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Editing',
-      completedLabel: 'Edited',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
-const META_fast_edit: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Built', icon: Wrench },
-    [ClientToolCallState.error]: { text: 'Failed to build', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped build', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted build', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Building',
-      completedLabel: 'Built',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
 const META_debug: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: { text: 'Debugging', icon: Loader2 },
@@ -2359,7 +2232,7 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   checkoff_todo: META_checkoff_todo,
   crawl_website: META_crawl_website,
   create_workspace_mcp_server: META_create_workspace_mcp_server,
-  build: META_build,
+  workflow: META_workflow,
   create_folder: META_create_folder,
   create_workflow: META_create_workflow,
   agent: META_agent,
@@ -2369,8 +2242,6 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   deploy_api: META_deploy_api,
   deploy_chat: META_deploy_chat,
   deploy_mcp: META_deploy_mcp,
-  edit: META_edit,
-  fast_edit: META_fast_edit,
   edit_workflow: META_edit_workflow,
   get_block_outputs: META_get_block_outputs,
   get_block_upstream_references: META_get_block_upstream_references,
@@ -2390,7 +2261,6 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   list_folders: META_list_folders,
   list_user_workspaces: META_list_user_workspaces,
   list_workspace_mcp_servers: META_list_workspace_mcp_servers,
-  make_api_request: META_make_api_request,
   manage_custom_tool: META_manage_custom_tool,
   manage_mcp_tool: META_manage_mcp_tool,
   manage_skill: META_manage_skill,
@@ -2401,7 +2271,6 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   oauth_get_auth_link: META_oauth_get_auth_link,
   oauth_request_access: META_oauth_request_access,
   open_resource: META_open_resource,
-  plan: META_plan,
   read: META_read,
   redeploy: META_redeploy,
   rename_workflow: META_rename_workflow,
diff --git a/apps/sim/lib/copilot/tool-descriptions.test.ts b/apps/sim/lib/copilot/tools/descriptions.test.ts
similarity index 97%
rename from apps/sim/lib/copilot/tool-descriptions.test.ts
rename to apps/sim/lib/copilot/tools/descriptions.test.ts
index df0a1183376..6bb7d11d037 100644
--- a/apps/sim/lib/copilot/tool-descriptions.test.ts
+++ b/apps/sim/lib/copilot/tools/descriptions.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { getCopilotToolDescription } from './descriptions'
 
 describe('getCopilotToolDescription', () => {
   it.concurrent('returns the base description when hosted keys are not active', () => {
diff --git a/apps/sim/lib/copilot/tool-descriptions.ts b/apps/sim/lib/copilot/tools/descriptions.ts
similarity index 100%
rename from apps/sim/lib/copilot/tool-descriptions.ts
rename to apps/sim/lib/copilot/tools/descriptions.ts
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/access.ts b/apps/sim/lib/copilot/tools/handlers/access.ts
similarity index 100%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/access.ts
rename to apps/sim/lib/copilot/tools/handlers/access.ts
diff --git a/apps/sim/lib/copilot/tools/handlers/context.ts b/apps/sim/lib/copilot/tools/handlers/context.ts
new file mode 100644
index 00000000000..5070da18479
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/context.ts
@@ -0,0 +1,22 @@
+import type { ExecutionContext } from '@/lib/copilot/request/types'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+import { getWorkflowById } from '@/lib/workflows/utils'
+
+export async function prepareExecutionContext(
+  userId: string,
+  workflowId: string,
+  chatId?: string
+): Promise<ExecutionContext> {
+  const wf = await getWorkflowById(workflowId)
+  const workspaceId = wf?.workspaceId ?? undefined
+
+  const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
+
+  return {
+    userId,
+    workflowId,
+    workspaceId,
+    chatId,
+    decryptedEnvVars,
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
similarity index 99%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts
rename to apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
index eb89c876cee..eaa30f4aaa8 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
@@ -2,7 +2,7 @@ import { db } from '@sim/db'
 import { chat, workflowMcpTool } from '@sim/db/schema'
 import { and, eq, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import { generateId } from '@/lib/core/utils/uuid'
 import { mcpPubSub } from '@/lib/mcp/pubsub'
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/manage.ts b/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
similarity index 99%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/manage.ts
rename to apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
index 233b1cbfe25..ac09e6d9c44 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/manage.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
@@ -8,7 +8,7 @@ import {
 } from '@sim/db/schema'
 import { and, eq, inArray, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { generateId } from '@/lib/core/utils/uuid'
 import { mcpPubSub } from '@/lib/mcp/pubsub'
 import { generateParameterSchemaForWorkflow } from '@/lib/mcp/workflow-mcp-sync'
diff --git a/apps/sim/lib/copilot/tools/handlers/function-execute.ts b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
new file mode 100644
index 00000000000..61cf5ed6219
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
@@ -0,0 +1,147 @@
+import { createLogger } from '@sim/logger'
+import { getTableById, queryRows } from '@/lib/table/service'
+import {
+  downloadWorkspaceFile,
+  findWorkspaceFileRecord,
+  getSandboxWorkspaceFilePath,
+  listWorkspaceFiles,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { executeTool as executeAppTool } from '@/tools'
+import type { ToolExecutionContext, ToolExecutionResult } from '../../tool-executor/types'
+
+const logger = createLogger('CopilotFunctionExecute')
+
+const MAX_FILE_SIZE = 10 * 1024 * 1024
+const MAX_TOTAL_SIZE = 50 * 1024 * 1024
+
+interface SandboxFile {
+  path: string
+  content: string
+}
+
+async function resolveInputFiles(
+  workspaceId: string,
+  inputFiles?: unknown[],
+  inputTables?: unknown[]
+): Promise<SandboxFile[]> {
+  const sandboxFiles: SandboxFile[] = []
+  let totalSize = 0
+
+  if (inputFiles?.length && workspaceId) {
+    const allFiles = await listWorkspaceFiles(workspaceId)
+    for (const fileRef of inputFiles) {
+      if (typeof fileRef !== 'string') continue
+      const record = findWorkspaceFileRecord(allFiles, fileRef)
+      if (!record) {
+        logger.warn('Input file not found', { fileRef })
+        continue
+      }
+      if (record.size > MAX_FILE_SIZE) {
+        logger.warn('Input file exceeds size limit', { fileId: record.id, size: record.size })
+        continue
+      }
+      if (totalSize + record.size > MAX_TOTAL_SIZE) {
+        logger.warn('Total input size limit reached')
+        break
+      }
+      const buffer = await downloadWorkspaceFile(record)
+      totalSize += buffer.length
+      const isText = /^text\/|application\/json|application\/xml|application\/csv/.test(
+        record.type || ''
+      )
+      const content = isText ? buffer.toString('utf-8') : buffer.toString('base64')
+      sandboxFiles.push({
+        path: getSandboxWorkspaceFilePath(record),
+        content,
+        encoding: isText ? undefined : 'base64',
+      } as SandboxFile)
+    }
+  }
+
+  if (inputTables?.length) {
+    for (const tableId of inputTables) {
+      if (typeof tableId !== 'string') continue
+      const table = await getTableById(tableId)
+      if (!table) {
+        logger.warn('Input table not found', { tableId })
+        continue
+      }
+      const rows = await queryRows(tableId, workspaceId, {}, 'copilot-fn-exec')
+      if (!rows.rows?.length) continue
+
+      const allKeys = new Set<string>()
+      for (const row of rows.rows) {
+        if (row.data && typeof row.data === 'object') {
+          for (const key of Object.keys(row.data as Record<string, unknown>)) {
+            allKeys.add(key)
+          }
+        }
+      }
+      const headers = Array.from(allKeys)
+      const csvLines = [headers.join(',')]
+      for (const row of rows.rows) {
+        const data = (row.data || {}) as Record<string, unknown>
+        csvLines.push(
+          headers
+            .map((h) => {
+              const val = data[h]
+              const str = val === null || val === undefined ? '' : String(val)
+              return str.includes(',') || str.includes('"') || str.includes('\n')
+                ? `"${str.replace(/"/g, '""')}"`
+                : str
+            })
+            .join(',')
+        )
+      }
+      const csvContent = csvLines.join('\n')
+      sandboxFiles.push({
+        path: `/home/user/tables/${tableId}.csv`,
+        content: csvContent,
+      })
+    }
+  }
+
+  return sandboxFiles
+}
+
+export async function executeFunctionExecute(
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+): Promise<ToolExecutionResult> {
+  const enrichedParams = { ...params }
+
+  if (context.decryptedEnvVars && Object.keys(context.decryptedEnvVars).length > 0) {
+    enrichedParams.envVars = {
+      ...context.decryptedEnvVars,
+      ...((enrichedParams.envVars as Record<string, string>) || {}),
+    }
+  }
+
+  if (context.workspaceId) {
+    const inputFiles = enrichedParams.inputFiles as unknown[] | undefined
+    const inputTables = enrichedParams.inputTables as unknown[] | undefined
+
+    if (inputFiles?.length || inputTables?.length) {
+      const resolved = await resolveInputFiles(context.workspaceId, inputFiles, inputTables)
+      if (resolved.length > 0) {
+        const existing = (enrichedParams._sandboxFiles as SandboxFile[]) || []
+        enrichedParams._sandboxFiles = [...existing, ...resolved]
+      }
+    }
+  }
+
+  enrichedParams._context = {
+    ...(typeof enrichedParams._context === 'object' && enrichedParams._context !== null
+      ? (enrichedParams._context as object)
+      : {}),
+    userId: context.userId,
+    workflowId: context.workflowId,
+    workspaceId: context.workspaceId,
+    chatId: context.chatId,
+    executionId: context.executionId,
+    runId: context.runId,
+    enforceCredentialAccess: true,
+  }
+
+  return executeAppTool('function_execute', enrichedParams, false)
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/job-tools.ts b/apps/sim/lib/copilot/tools/handlers/jobs.ts
similarity index 99%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/job-tools.ts
rename to apps/sim/lib/copilot/tools/handlers/jobs.ts
index 00d18a6188d..fa1d9107cb1 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/job-tools.ts
+++ b/apps/sim/lib/copilot/tools/handlers/jobs.ts
@@ -3,7 +3,7 @@ import { copilotChats, workflowSchedule } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { generateId } from '@/lib/core/utils/uuid'
 import { parseCronToHumanReadable, validateCronExpression } from '@/lib/workflows/schedules/utils'
 
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-credential.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-credential.ts
new file mode 100644
index 00000000000..ce6c234147b
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-credential.ts
@@ -0,0 +1,44 @@
+import { db } from '@sim/db'
+import { credential } from '@sim/db/schema'
+import { eq } from 'drizzle-orm'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+
+export function executeManageCredential(
+  rawParams: Record<string, unknown>,
+  _context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as { operation: string; credentialId: string; displayName?: string }
+  const { operation, credentialId, displayName } = params
+  if (!credentialId) return Promise.resolve({ success: false, error: 'credentialId is required' })
+  return (async () => {
+    try {
+      const [row] = await db
+        .select({ id: credential.id, type: credential.type, displayName: credential.displayName })
+        .from(credential)
+        .where(eq(credential.id, credentialId))
+        .limit(1)
+      if (!row) return { success: false, error: 'Credential not found' }
+      if (row.type !== 'oauth')
+        return { success: false, error: 'Only OAuth credentials can be managed with this tool.' }
+      switch (operation) {
+        case 'rename':
+          if (!displayName) return { success: false, error: 'displayName is required for rename' }
+          await db
+            .update(credential)
+            .set({ displayName, updatedAt: new Date() })
+            .where(eq(credential.id, credentialId))
+          return { success: true, output: { credentialId, displayName } }
+        case 'delete':
+          await db.delete(credential).where(eq(credential.id, credentialId))
+          return { success: true, output: { credentialId, deleted: true } }
+        default:
+          return {
+            success: false,
+            error: `Unknown operation: ${operation}. Use "rename" or "delete".`,
+          }
+      }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })()
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
new file mode 100644
index 00000000000..57b0efd433c
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
@@ -0,0 +1,207 @@
+import { createLogger } from '@sim/logger'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import {
+  deleteCustomTool,
+  getCustomToolById,
+  listCustomTools,
+  upsertCustomTools,
+} from '@/lib/workflows/custom-tools/operations'
+
+const logger = createLogger('CopilotToolExecutor')
+
+type ManageCustomToolOperation = 'add' | 'edit' | 'delete' | 'list'
+
+interface ManageCustomToolSchema {
+  type: 'function'
+  function: {
+    name: string
+    description?: string
+    parameters: Record<string, unknown>
+  }
+}
+
+interface ManageCustomToolParams {
+  operation?: string
+  toolId?: string
+  schema?: ManageCustomToolSchema
+  code?: string
+  title?: string
+  workspaceId?: string
+}
+
+export async function executeManageCustomTool(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as ManageCustomToolParams
+  const operation = String(params.operation || '').toLowerCase() as ManageCustomToolOperation
+  const workspaceId = params.workspaceId || context.workspaceId
+
+  if (!operation) {
+    return { success: false, error: "Missing required 'operation' argument" }
+  }
+
+  const writeOps: string[] = ['add', 'edit', 'delete']
+  if (
+    writeOps.includes(operation) &&
+    context.userPermission &&
+    context.userPermission !== 'write' &&
+    context.userPermission !== 'admin'
+  ) {
+    return {
+      success: false,
+      error: `Permission denied: '${operation}' on manage_custom_tool requires write access. You have '${context.userPermission}' permission.`,
+    }
+  }
+
+  try {
+    if (operation === 'list') {
+      const toolsForUser = await listCustomTools({
+        userId: context.userId,
+        workspaceId,
+      })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          tools: toolsForUser,
+          count: toolsForUser.length,
+        },
+      }
+    }
+
+    if (operation === 'add') {
+      if (!workspaceId) {
+        return {
+          success: false,
+          error: "workspaceId is required for operation 'add'",
+        }
+      }
+      if (!params.schema || !params.code) {
+        return {
+          success: false,
+          error: "Both 'schema' and 'code' are required for operation 'add'",
+        }
+      }
+
+      const title = params.title || params.schema.function?.name
+      if (!title) {
+        return { success: false, error: "Missing tool title or schema.function.name for 'add'" }
+      }
+
+      const resultTools = await upsertCustomTools({
+        tools: [{ title, schema: params.schema, code: params.code }],
+        workspaceId,
+        userId: context.userId,
+      })
+      const created = resultTools.find((tool) => tool.title === title)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          toolId: created?.id,
+          title,
+          message: `Created custom tool "${title}"`,
+        },
+      }
+    }
+
+    if (operation === 'edit') {
+      if (!workspaceId) {
+        return {
+          success: false,
+          error: "workspaceId is required for operation 'edit'",
+        }
+      }
+      if (!params.toolId) {
+        return { success: false, error: "'toolId' is required for operation 'edit'" }
+      }
+      if (!params.schema && !params.code) {
+        return {
+          success: false,
+          error: "At least one of 'schema' or 'code' is required for operation 'edit'",
+        }
+      }
+
+      const existing = await getCustomToolById({
+        toolId: params.toolId,
+        userId: context.userId,
+        workspaceId,
+      })
+      if (!existing) {
+        return { success: false, error: `Custom tool not found: ${params.toolId}` }
+      }
+
+      const mergedSchema = params.schema || (existing.schema as ManageCustomToolSchema)
+      const mergedCode = params.code || existing.code
+      const title = params.title || mergedSchema.function?.name || existing.title
+
+      await upsertCustomTools({
+        tools: [{ id: params.toolId, title, schema: mergedSchema, code: mergedCode }],
+        workspaceId,
+        userId: context.userId,
+      })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          toolId: params.toolId,
+          title,
+          message: `Updated custom tool "${title}"`,
+        },
+      }
+    }
+
+    if (operation === 'delete') {
+      if (!params.toolId) {
+        return { success: false, error: "'toolId' is required for operation 'delete'" }
+      }
+
+      const deleted = await deleteCustomTool({
+        toolId: params.toolId,
+        userId: context.userId,
+        workspaceId,
+      })
+      if (!deleted) {
+        return { success: false, error: `Custom tool not found: ${params.toolId}` }
+      }
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          toolId: params.toolId,
+          message: 'Deleted custom tool',
+        },
+      }
+    }
+
+    return {
+      success: false,
+      error: `Unsupported operation for manage_custom_tool: ${operation}`,
+    }
+  } catch (error) {
+    logger.error(
+      context.messageId
+        ? `manage_custom_tool execution failed [messageId:${context.messageId}]`
+        : 'manage_custom_tool execution failed',
+      {
+        operation,
+        workspaceId,
+        userId: context.userId,
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to manage custom tool',
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
new file mode 100644
index 00000000000..be7b327bdbc
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
@@ -0,0 +1,246 @@
+import { db } from '@sim/db'
+import { mcpServers } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, isNull } from 'drizzle-orm'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { validateMcpDomain } from '@/lib/mcp/domain-check'
+import { mcpService } from '@/lib/mcp/service'
+import { generateMcpServerId } from '@/lib/mcp/utils'
+
+const logger = createLogger('CopilotToolExecutor')
+
+type ManageMcpToolOperation = 'add' | 'edit' | 'delete' | 'list'
+
+interface ManageMcpToolConfig {
+  name?: string
+  transport?: string
+  url?: string
+  headers?: Record<string, string>
+  timeout?: number
+  enabled?: boolean
+}
+
+interface ManageMcpToolParams {
+  operation?: string
+  serverId?: string
+  config?: ManageMcpToolConfig
+}
+
+export async function executeManageMcpTool(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as ManageMcpToolParams
+  const operation = String(params.operation || '').toLowerCase() as ManageMcpToolOperation
+  const workspaceId = context.workspaceId
+
+  if (!operation) {
+    return { success: false, error: "Missing required 'operation' argument" }
+  }
+
+  if (!workspaceId) {
+    return { success: false, error: 'workspaceId is required' }
+  }
+
+  const writeOps: string[] = ['add', 'edit', 'delete']
+  if (
+    writeOps.includes(operation) &&
+    context.userPermission &&
+    context.userPermission !== 'write' &&
+    context.userPermission !== 'admin'
+  ) {
+    return {
+      success: false,
+      error: `Permission denied: '${operation}' on manage_mcp_tool requires write access. You have '${context.userPermission}' permission.`,
+    }
+  }
+
+  try {
+    if (operation === 'list') {
+      const servers = await db
+        .select()
+        .from(mcpServers)
+        .where(and(eq(mcpServers.workspaceId, workspaceId), isNull(mcpServers.deletedAt)))
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          servers: servers.map((s) => ({
+            id: s.id,
+            name: s.name,
+            url: s.url,
+            transport: s.transport,
+            enabled: s.enabled,
+            connectionStatus: s.connectionStatus,
+          })),
+          count: servers.length,
+        },
+      }
+    }
+
+    if (operation === 'add') {
+      const config = params.config
+      if (!config?.name || !config?.url) {
+        return { success: false, error: "config.name and config.url are required for 'add'" }
+      }
+
+      validateMcpDomain(config.url)
+
+      const serverId = generateMcpServerId(workspaceId, config.url)
+
+      const [existing] = await db
+        .select({ id: mcpServers.id, deletedAt: mcpServers.deletedAt })
+        .from(mcpServers)
+        .where(and(eq(mcpServers.id, serverId), eq(mcpServers.workspaceId, workspaceId)))
+        .limit(1)
+
+      if (existing) {
+        await db
+          .update(mcpServers)
+          .set({
+            name: config.name,
+            transport: config.transport || 'streamable-http',
+            url: config.url,
+            headers: config.headers || {},
+            timeout: config.timeout || 30000,
+            enabled: config.enabled !== false,
+            connectionStatus: 'connected',
+            lastConnected: new Date(),
+            updatedAt: new Date(),
+            deletedAt: null,
+          })
+          .where(eq(mcpServers.id, serverId))
+      } else {
+        await db.insert(mcpServers).values({
+          id: serverId,
+          workspaceId,
+          createdBy: context.userId,
+          name: config.name,
+          description: '',
+          transport: config.transport || 'streamable-http',
+          url: config.url,
+          headers: config.headers || {},
+          timeout: config.timeout || 30000,
+          retries: 3,
+          enabled: config.enabled !== false,
+          connectionStatus: 'connected',
+          lastConnected: new Date(),
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        })
+      }
+
+      await mcpService.clearCache(workspaceId)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          serverId,
+          name: config.name,
+          message: existing
+            ? `Updated existing MCP server "${config.name}"`
+            : `Added MCP server "${config.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'edit') {
+      if (!params.serverId) {
+        return { success: false, error: "'serverId' is required for 'edit'" }
+      }
+      const config = params.config
+      if (!config) {
+        return { success: false, error: "'config' is required for 'edit'" }
+      }
+
+      if (config.url) {
+        validateMcpDomain(config.url)
+      }
+
+      const updateData: Record<string, unknown> = { updatedAt: new Date() }
+      if (config.name !== undefined) updateData.name = config.name
+      if (config.transport !== undefined) updateData.transport = config.transport
+      if (config.url !== undefined) updateData.url = config.url
+      if (config.headers !== undefined) updateData.headers = config.headers
+      if (config.timeout !== undefined) updateData.timeout = config.timeout
+      if (config.enabled !== undefined) updateData.enabled = config.enabled
+
+      const [updated] = await db
+        .update(mcpServers)
+        .set(updateData)
+        .where(
+          and(
+            eq(mcpServers.id, params.serverId),
+            eq(mcpServers.workspaceId, workspaceId),
+            isNull(mcpServers.deletedAt)
+          )
+        )
+        .returning()
+
+      if (!updated) {
+        return { success: false, error: `MCP server not found: ${params.serverId}` }
+      }
+
+      await mcpService.clearCache(workspaceId)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          serverId: params.serverId,
+          name: updated.name,
+          message: `Updated MCP server "${updated.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'delete') {
+      if (!params.serverId) {
+        return { success: false, error: "'serverId' is required for 'delete'" }
+      }
+
+      const [deleted] = await db
+        .delete(mcpServers)
+        .where(and(eq(mcpServers.id, params.serverId), eq(mcpServers.workspaceId, workspaceId)))
+        .returning()
+
+      if (!deleted) {
+        return { success: false, error: `MCP server not found: ${params.serverId}` }
+      }
+
+      await mcpService.clearCache(workspaceId)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          serverId: params.serverId,
+          message: `Deleted MCP server "${deleted.name}"`,
+        },
+      }
+    }
+
+    return { success: false, error: `Unsupported operation for manage_mcp_tool: ${operation}` }
+  } catch (error) {
+    logger.error(
+      context.messageId
+        ? `manage_mcp_tool execution failed [messageId:${context.messageId}]`
+        : 'manage_mcp_tool execution failed',
+      {
+        operation,
+        workspaceId,
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to manage MCP server',
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-skill.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-skill.ts
new file mode 100644
index 00000000000..a1e5ed7de9e
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-skill.ts
@@ -0,0 +1,173 @@
+import { createLogger } from '@sim/logger'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { deleteSkill, listSkills, upsertSkills } from '@/lib/workflows/skills/operations'
+
+const logger = createLogger('CopilotToolExecutor')
+
+type ManageSkillOperation = 'add' | 'edit' | 'delete' | 'list'
+
+interface ManageSkillParams {
+  operation?: string
+  skillId?: string
+  name?: string
+  description?: string
+  content?: string
+}
+
+export async function executeManageSkill(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as ManageSkillParams
+  const operation = String(params.operation || '').toLowerCase() as ManageSkillOperation
+  const workspaceId = context.workspaceId
+
+  if (!operation) {
+    return { success: false, error: "Missing required 'operation' argument" }
+  }
+
+  if (!workspaceId) {
+    return { success: false, error: 'workspaceId is required' }
+  }
+
+  const writeOps: string[] = ['add', 'edit', 'delete']
+  if (
+    writeOps.includes(operation) &&
+    context.userPermission &&
+    context.userPermission !== 'write' &&
+    context.userPermission !== 'admin'
+  ) {
+    return {
+      success: false,
+      error: `Permission denied: '${operation}' on manage_skill requires write access. You have '${context.userPermission}' permission.`,
+    }
+  }
+
+  try {
+    if (operation === 'list') {
+      const skills = await listSkills({ workspaceId })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skills: skills.map((s) => ({
+            id: s.id,
+            name: s.name,
+            description: s.description,
+            createdAt: s.createdAt,
+          })),
+          count: skills.length,
+        },
+      }
+    }
+
+    if (operation === 'add') {
+      if (!params.name || !params.description || !params.content) {
+        return {
+          success: false,
+          error: "'name', 'description', and 'content' are required for 'add'",
+        }
+      }
+
+      const resultSkills = await upsertSkills({
+        skills: [{ name: params.name, description: params.description, content: params.content }],
+        workspaceId,
+        userId: context.userId,
+      })
+      const created = resultSkills.find((s) => s.name === params.name)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skillId: created?.id,
+          name: params.name,
+          message: `Created skill "${params.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'edit') {
+      if (!params.skillId) {
+        return { success: false, error: "'skillId' is required for 'edit'" }
+      }
+      if (!params.name && !params.description && !params.content) {
+        return {
+          success: false,
+          error: "At least one of 'name', 'description', or 'content' is required for 'edit'",
+        }
+      }
+
+      const existing = await listSkills({ workspaceId })
+      const found = existing.find((s) => s.id === params.skillId)
+      if (!found) {
+        return { success: false, error: `Skill not found: ${params.skillId}` }
+      }
+
+      await upsertSkills({
+        skills: [
+          {
+            id: params.skillId,
+            name: params.name || found.name,
+            description: params.description || found.description,
+            content: params.content || found.content,
+          },
+        ],
+        workspaceId,
+        userId: context.userId,
+      })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skillId: params.skillId,
+          name: params.name || found.name,
+          message: `Updated skill "${params.name || found.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'delete') {
+      if (!params.skillId) {
+        return { success: false, error: "'skillId' is required for 'delete'" }
+      }
+
+      const deleted = await deleteSkill({ skillId: params.skillId, workspaceId })
+      if (!deleted) {
+        return { success: false, error: `Skill not found: ${params.skillId}` }
+      }
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skillId: params.skillId,
+          message: 'Deleted skill',
+        },
+      }
+    }
+
+    return { success: false, error: `Unsupported operation for manage_skill: ${operation}` }
+  } catch (error) {
+    logger.error(
+      context.messageId
+        ? `manage_skill execution failed [messageId:${context.messageId}]`
+        : 'manage_skill execution failed',
+      {
+        operation,
+        workspaceId,
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to manage skill',
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/materialize-file.ts b/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
similarity index 98%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/materialize-file.ts
rename to apps/sim/lib/copilot/tools/handlers/materialize-file.ts
index 6b2542394b9..fbcf357f8df 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/materialize-file.ts
+++ b/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
@@ -3,8 +3,8 @@ import { workflow, workspaceFiles } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import { findMothershipUploadRowByChatAndName } from '@/lib/copilot/orchestrator/tool-executor/upload-file-reader'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { findMothershipUploadRowByChatAndName } from '@/lib/copilot/tools/handlers/upload-file-reader'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getServePathPrefix } from '@/lib/uploads'
 import { downloadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
diff --git a/apps/sim/lib/copilot/tools/handlers/oauth.ts b/apps/sim/lib/copilot/tools/handlers/oauth.ts
new file mode 100644
index 00000000000..7ece3645fce
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/oauth.ts
@@ -0,0 +1,177 @@
+import { db } from '@sim/db'
+import { pendingCredentialDraft, user } from '@sim/db/schema'
+import { and, eq, lt } from 'drizzle-orm'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import { getAllOAuthServices } from '@/lib/oauth/utils'
+
+export async function executeOAuthGetAuthLink(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const providerName = String(rawParams.providerName || rawParams.provider_name || '')
+  const baseUrl = getBaseUrl()
+  try {
+    const result = await generateOAuthLink(
+      context.userId,
+      context.workspaceId,
+      context.workflowId,
+      context.chatId,
+      providerName,
+      baseUrl
+    )
+    return {
+      success: true,
+      output: {
+        message: `Authorization URL generated for ${result.serviceName}.`,
+        oauth_url: result.url,
+        instructions: `Open this URL in your browser to connect ${result.serviceName}: ${result.url}`,
+        provider: result.serviceName,
+        providerId: result.providerId,
+      },
+    }
+  } catch (err) {
+    const workspaceUrl = context.workspaceId
+      ? `${baseUrl}/workspace/${context.workspaceId}`
+      : `${baseUrl}/workspace`
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      output: {
+        message: `Could not generate a direct OAuth link for ${providerName}. Connect manually from the workspace.`,
+        oauth_url: workspaceUrl,
+        error: err instanceof Error ? err.message : String(err),
+      },
+    }
+  }
+}
+
+export async function executeOAuthRequestAccess(
+  rawParams: Record<string, unknown>,
+  _context: ExecutionContext
+): Promise<ToolCallResult> {
+  const providerName = String(rawParams.providerName || rawParams.provider_name || 'the provider')
+  return {
+    success: true,
+    output: {
+      status: 'requested',
+      providerName,
+      message: `Requested ${providerName} OAuth connection.`,
+    },
+  }
+}
+
+/**
+ * Resolves a human-friendly provider name to a providerId and generates the
+ * actual OAuth authorization URL via Better Auth's server-side API.
+ *
+ * Steps: resolve provider → create credential draft → look up user session →
+ * call auth.api.oAuth2LinkAccount → return the real authorization URL.
+ */
+export async function generateOAuthLink(
+  userId: string,
+  workspaceId: string | undefined,
+  workflowId: string | undefined,
+  chatId: string | undefined,
+  providerName: string,
+  baseUrl: string
+): Promise<{ url: string; providerId: string; serviceName: string }> {
+  if (!workspaceId) {
+    throw new Error('workspaceId is required to generate an OAuth link')
+  }
+
+  const allServices = getAllOAuthServices()
+  const normalizedInput = providerName.toLowerCase().trim()
+
+  const matched =
+    allServices.find((s) => s.providerId === normalizedInput) ||
+    allServices.find((s) => s.name.toLowerCase() === normalizedInput) ||
+    allServices.find(
+      (s) =>
+        s.name.toLowerCase().includes(normalizedInput) ||
+        normalizedInput.includes(s.name.toLowerCase())
+    ) ||
+    allServices.find(
+      (s) => s.providerId.includes(normalizedInput) || normalizedInput.includes(s.providerId)
+    )
+
+  if (!matched) {
+    const available = allServices.map((s) => s.name).join(', ')
+    throw new Error(`Provider "${providerName}" not found. Available providers: ${available}`)
+  }
+
+  const { providerId, name: serviceName } = matched
+  const callbackURL =
+    workflowId && workspaceId
+      ? `${baseUrl}/workspace/${workspaceId}/w/${workflowId}`
+      : chatId && workspaceId
+        ? `${baseUrl}/workspace/${workspaceId}/task/${chatId}`
+        : `${baseUrl}/workspace/${workspaceId}`
+
+  if (providerId === 'trello') {
+    return { url: `${baseUrl}/api/auth/trello/authorize`, providerId, serviceName }
+  }
+  if (providerId === 'shopify') {
+    const returnUrl = encodeURIComponent(callbackURL)
+    return {
+      url: `${baseUrl}/api/auth/shopify/authorize?returnUrl=${returnUrl}`,
+      providerId,
+      serviceName,
+    }
+  }
+
+  let displayName = serviceName
+  try {
+    const [row] = await db.select({ name: user.name }).from(user).where(eq(user.id, userId))
+    if (row?.name) {
+      displayName = `${row.name}'s ${serviceName}`
+    }
+  } catch {
+    // Fall back to service name only
+  }
+
+  const now = new Date()
+  await db
+    .delete(pendingCredentialDraft)
+    .where(
+      and(eq(pendingCredentialDraft.userId, userId), lt(pendingCredentialDraft.expiresAt, now))
+    )
+  await db
+    .insert(pendingCredentialDraft)
+    .values({
+      id: crypto.randomUUID(),
+      userId,
+      workspaceId,
+      providerId,
+      displayName,
+      expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
+      createdAt: now,
+    })
+    .onConflictDoUpdate({
+      target: [
+        pendingCredentialDraft.userId,
+        pendingCredentialDraft.providerId,
+        pendingCredentialDraft.workspaceId,
+      ],
+      set: {
+        displayName,
+        expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
+        createdAt: now,
+      },
+    })
+
+  const { auth } = await import('@/lib/auth/auth')
+  const { headers: getHeaders } = await import('next/headers')
+  const reqHeaders = await getHeaders()
+
+  const data = (await auth.api.oAuth2LinkAccount({
+    body: { providerId, callbackURL },
+    headers: reqHeaders,
+  })) as { url?: string; redirect?: boolean }
+
+  if (!data?.url) {
+    throw new Error('oAuth2LinkAccount did not return an authorization URL')
+  }
+
+  return { url: data.url, providerId, serviceName }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts b/apps/sim/lib/copilot/tools/handlers/param-types.ts
similarity index 97%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts
rename to apps/sim/lib/copilot/tools/handlers/param-types.ts
index 660e62d67b0..ccef1180903 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts
+++ b/apps/sim/lib/copilot/tools/handlers/param-types.ts
@@ -3,6 +3,8 @@
  * Replaces Record<string, any> with specific shapes based on actual property access.
  */
 
+import type { MothershipResourceType } from '@/lib/copilot/resources/types'
+
 // === Workflow Query Params ===
 
 export interface GetWorkflowDataParams {
@@ -203,7 +205,7 @@ export interface DeleteWorkspaceMcpServerParams {
   serverId: string
 }
 
-export type OpenResourceType = 'workflow' | 'table' | 'knowledgebase' | 'file'
+export type OpenResourceType = MothershipResourceType
 
 export interface OpenResourceParams {
   type?: OpenResourceType
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/platform-actions.ts b/apps/sim/lib/copilot/tools/handlers/platform-actions.ts
similarity index 100%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/platform-actions.ts
rename to apps/sim/lib/copilot/tools/handlers/platform-actions.ts
diff --git a/apps/sim/lib/copilot/tools/handlers/platform.ts b/apps/sim/lib/copilot/tools/handlers/platform.ts
new file mode 100644
index 00000000000..f5cc43f910b
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/platform.ts
@@ -0,0 +1,9 @@
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
+
+export async function executeGetPlatformActions(
+  _rawParams: Record<string, unknown>,
+  _context: ExecutionContext
+): Promise<ToolCallResult> {
+  return { success: true, output: { content: PLATFORM_ACTIONS_CONTENT } }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/resources.ts b/apps/sim/lib/copilot/tools/handlers/resources.ts
new file mode 100644
index 00000000000..43a68386095
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/resources.ts
@@ -0,0 +1,95 @@
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { MothershipResourceType } from '@/lib/copilot/resources/types'
+import { getKnowledgeBaseById } from '@/lib/knowledge/service'
+import { getTableById } from '@/lib/table/service'
+import { getWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { getWorkflowById } from '@/lib/workflows/utils'
+import { isUuid } from '@/executor/constants'
+import type { OpenResourceParams, ValidOpenResourceParams } from './param-types'
+
+const VALID_OPEN_RESOURCE_TYPES = new Set(Object.values(MothershipResourceType))
+
+export async function executeOpenResource(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as OpenResourceParams
+  const validated = validateOpenResourceParams(params)
+  if (!validated.success) return { success: false, error: validated.error }
+
+  const resourceType = validated.params.type
+  let resourceId = validated.params.id
+  let title: string = resourceType
+
+  if (resourceType === 'file') {
+    if (!context.workspaceId)
+      return { success: false, error: 'Opening a workspace file requires workspace context.' }
+    if (!isUuid(validated.params.id))
+      return { success: false, error: 'open_resource for files requires the canonical file UUID.' }
+    const record = await getWorkspaceFile(context.workspaceId, validated.params.id)
+    if (!record)
+      return { success: false, error: `No workspace file with id "${validated.params.id}".` }
+    resourceId = record.id
+    title = record.name
+  }
+  if (resourceType === 'workflow') {
+    const wf = await getWorkflowById(validated.params.id)
+    if (!wf) return { success: false, error: `No workflow with id "${validated.params.id}".` }
+    if (context.workspaceId && wf.workspaceId !== context.workspaceId)
+      return { success: false, error: `Workflow not found in the current workspace.` }
+    resourceId = wf.id
+    title = wf.name
+  }
+  if (resourceType === 'table') {
+    const tbl = await getTableById(validated.params.id)
+    if (!tbl) return { success: false, error: `No table with id "${validated.params.id}".` }
+    if (context.workspaceId && tbl.workspaceId !== context.workspaceId)
+      return { success: false, error: `Table not found in the current workspace.` }
+    resourceId = tbl.id
+    title = tbl.name
+  }
+  if (resourceType === 'knowledgebase') {
+    const kb = await getKnowledgeBaseById(validated.params.id)
+    if (!kb) return { success: false, error: `No knowledge base with id "${validated.params.id}".` }
+    if (context.workspaceId && kb.workspaceId !== context.workspaceId)
+      return { success: false, error: `Knowledge base not found in the current workspace.` }
+    resourceId = kb.id
+    title = kb.name
+  }
+
+  return {
+    success: true,
+    output: { message: `Opened ${resourceType} ${resourceId} for the user` },
+    resources: [
+      {
+        type: resourceType,
+        id: resourceId,
+        title,
+      },
+    ],
+  }
+}
+
+function validateOpenResourceParams(
+  params: OpenResourceParams
+): { success: true; params: ValidOpenResourceParams } | { success: false; error: string } {
+  if (!params.type) {
+    return { success: false, error: 'type is required' }
+  }
+
+  if (!VALID_OPEN_RESOURCE_TYPES.has(params.type)) {
+    return { success: false, error: `Invalid resource type: ${params.type}` }
+  }
+
+  if (!params.id) {
+    return { success: false, error: `${params.type} resources require \`id\`` }
+  }
+
+  return {
+    success: true,
+    params: {
+      type: params.type,
+      id: params.id,
+    },
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/upload-file-reader.ts b/apps/sim/lib/copilot/tools/handlers/upload-file-reader.ts
similarity index 100%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/upload-file-reader.ts
rename to apps/sim/lib/copilot/tools/handlers/upload-file-reader.ts
diff --git a/apps/sim/lib/copilot/tools/handlers/vfs.test.ts b/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
new file mode 100644
index 00000000000..40431c7445b
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
@@ -0,0 +1,89 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { getOrMaterializeVFS } = vi.hoisted(() => ({
+  getOrMaterializeVFS: vi.fn(),
+}))
+
+const { readChatUpload } = vi.hoisted(() => ({
+  readChatUpload: vi.fn(),
+}))
+
+vi.mock('@sim/logger', () => loggerMock)
+vi.mock('@/lib/copilot/vfs', () => ({
+  getOrMaterializeVFS,
+}))
+vi.mock('./upload-file-reader', () => ({
+  readChatUpload,
+  listChatUploads: vi.fn(),
+}))
+
+import { executeVfsGrep, executeVfsRead } from './vfs'
+
+function makeVfs() {
+  return {
+    grep: vi.fn(),
+    read: vi.fn(),
+    readFileContent: vi.fn(),
+    suggestSimilar: vi.fn().mockReturnValue([]),
+  }
+}
+
+describe('vfs handlers oversize policy', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('fails oversized grep results with narrowing guidance', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([
+      { path: 'files/a.txt', line: 1, content: 'a'.repeat(60_000) },
+      { path: 'files/b.txt', line: 2, content: 'b'.repeat(60_000) },
+    ])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGrep(
+      { pattern: 'foo', output_mode: 'content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('smaller grep')
+  })
+
+  it('fails oversized read results with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue({ content: 'a'.repeat(100_001), totalLines: 1 })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+  })
+
+  it('fails file-backed oversized read placeholders with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue(null)
+    vfs.readFileContent.mockResolvedValue({
+      content: '[File too large to display inline: big.txt (6000000 bytes, limit 5242880)]',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+  })
+})
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/vfs-tools.ts b/apps/sim/lib/copilot/tools/handlers/vfs.ts
similarity index 76%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/vfs-tools.ts
rename to apps/sim/lib/copilot/tools/handlers/vfs.ts
index c2e37759436..9a9afe5ab0a 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/vfs-tools.ts
+++ b/apps/sim/lib/copilot/tools/handlers/vfs.ts
@@ -1,10 +1,26 @@
 import { createLogger } from '@sim/logger'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { getOrMaterializeVFS } from '@/lib/copilot/vfs'
 import { listChatUploads, readChatUpload } from './upload-file-reader'
 
 const logger = createLogger('VfsTools')
 
+function serializedResultSize(value: unknown): number {
+  try {
+    return JSON.stringify(value).length
+  } catch {
+    return String(value).length
+  }
+}
+
+function isOversizedReadPlaceholder(content: string): boolean {
+  return (
+    content.startsWith('[File too large to display inline:') ||
+    content.startsWith('[Image too large:')
+  )
+}
+
 export async function executeVfsGrep(
   params: Record<string, unknown>,
   context: ExecutionContext
@@ -36,8 +52,16 @@ export async function executeVfsGrep(
       : typeof result === 'object'
         ? Object.keys(result).length
         : 0
+    const output = { [key]: result }
+    if (serializedResultSize(output) > TOOL_RESULT_MAX_INLINE_CHARS) {
+      return {
+        success: false,
+        error:
+          'Grep result too large to return inline. Use a smaller grep by narrowing the pattern/path, reducing context, or lowering maxResults.',
+      }
+    }
     logger.debug('vfs_grep result', { pattern, path: params.path, outputMode, matchCount })
-    return { success: true, output: { [key]: result } }
+    return { success: true, output }
   } catch (err) {
     logger.error('vfs_grep failed', {
       pattern,
@@ -106,6 +130,16 @@ export async function executeVfsRead(
       const filename = path.slice('uploads/'.length)
       const uploadResult = await readChatUpload(filename, context.chatId)
       if (uploadResult) {
+        if (
+          isOversizedReadPlaceholder(uploadResult.content) ||
+          serializedResultSize(uploadResult) > TOOL_RESULT_MAX_INLINE_CHARS
+        ) {
+          return {
+            success: false,
+            error:
+              'Read result too large to return inline. Use grep on this path instead of reading it directly, or retry read with offset/limit.',
+          }
+        }
         logger.debug('vfs_read resolved chat upload', { path, totalLines: uploadResult.totalLines })
         return { success: true, output: uploadResult }
       }
@@ -124,6 +158,16 @@ export async function executeVfsRead(
     if (!result) {
       const fileContent = await vfs.readFileContent(path)
       if (fileContent) {
+        if (
+          isOversizedReadPlaceholder(fileContent.content) ||
+          serializedResultSize(fileContent) > TOOL_RESULT_MAX_INLINE_CHARS
+        ) {
+          return {
+            success: false,
+            error:
+              'Read result too large to return inline. Use grep on this path instead of reading it directly, or retry read with offset/limit.',
+          }
+        }
         logger.debug('vfs_read resolved workspace file', {
           path,
           totalLines: fileContent.totalLines,
@@ -142,6 +186,16 @@ export async function executeVfsRead(
           : ' Use glob to discover available paths.'
       return { success: false, error: `File not found: ${path}.${hint}` }
     }
+    if (
+      isOversizedReadPlaceholder(result.content) ||
+      serializedResultSize(result) > TOOL_RESULT_MAX_INLINE_CHARS
+    ) {
+      return {
+        success: false,
+        error:
+          'Read result too large to return inline. Use grep on this path instead of reading it directly, or retry read with offset/limit.',
+      }
+    }
     logger.debug('vfs_read result', { path, totalLines: result.totalLines })
     return {
       success: true,
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/mutations.ts b/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
similarity index 99%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/mutations.ts
rename to apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
index c2a378cb768..8e2d82d9554 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/mutations.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
@@ -1,7 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { createWorkspaceApiKey } from '@/lib/api-key/auth'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { generateId } from '@/lib/core/utils/uuid'
 import { executeWorkflow } from '@/lib/workflows/executor/execute-workflow'
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/queries.ts b/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
similarity index 99%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/queries.ts
rename to apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
index 2148a2c0cb1..75755a59ee1 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/queries.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
@@ -1,4 +1,4 @@
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { formatNormalizedWorkflowForCopilot } from '@/lib/copilot/tools/shared/workflow-utils'
 import { mcpService } from '@/lib/mcp/service'
 import { listWorkspaceFiles } from '@/lib/uploads/contexts/workspace'
diff --git a/apps/sim/lib/copilot/tools/mcp/definitions.ts b/apps/sim/lib/copilot/tools/mcp/definitions.ts
index 6ca813a3b3e..22b2e1d5164 100644
--- a/apps/sim/lib/copilot/tools/mcp/definitions.ts
+++ b/apps/sim/lib/copilot/tools/mcp/definitions.ts
@@ -58,7 +58,7 @@ export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
     name: 'create_workflow',
     toolId: 'create_workflow',
     description:
-      'Create a new empty workflow. Returns the new workflow ID. Always call this FIRST before sim_build for new workflows. Use workspaceId to place it in a specific workspace.',
+      'Create a new empty workflow. Returns the new workflow ID. Always call this FIRST before sim_workflow for new workflows. Use workspaceId to place it in a specific workspace.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -263,14 +263,15 @@ export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
 
 export const SUBAGENT_TOOL_DEFS: SubagentToolDef[] = [
   {
-    name: 'sim_build',
-    agentId: 'build',
-    description: `Build a workflow end-to-end in a single step. This is the fast mode equivalent for headless/MCP usage.
+    name: 'sim_workflow',
+    agentId: 'workflow',
+    description: `Create, modify, test, debug, and organize workflows end-to-end in a single step.
 
 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
+- You want to gather information and build in one pass
+- Moving, renaming, or organizing workflows and folders
 
 WORKFLOW ID (REQUIRED):
 - For NEW workflows: First call create_workflow to get a workflowId, then pass it here
@@ -282,6 +283,7 @@ CAN DO:
 - Add, modify, or remove blocks
 - Configure block settings and connections
 - Set environment variables and workflow variables
+- Move, rename, delete workflows and folders
 
 CANNOT DO:
 - Run or test workflows (use sim_test separately)
@@ -289,8 +291,8 @@ CANNOT DO:
 
 WORKFLOW:
 1. Call create_workflow to get a workflowId (for new workflows)
-2. Call sim_build with the request and workflowId
-3. Build agent gathers info and builds in one pass
+2. Call sim_workflow with the request and workflowId
+3. Workflow agent gathers info and builds in one pass
 4. Call sim_test to verify it works
 5. Optionally call sim_deploy to make it externally accessible`,
     inputSchema: {
@@ -298,7 +300,7 @@ WORKFLOW:
       properties: {
         request: {
           type: 'string',
-          description: 'What you want to build or modify in the workflow.',
+          description: 'What you want to build, modify, or organize.',
         },
         workflowId: {
           type: 'string',
@@ -337,77 +339,6 @@ DO NOT USE (use direct tools instead):
     },
     annotations: { readOnlyHint: true },
   },
-  {
-    name: 'sim_plan',
-    agentId: 'plan',
-    description: `Plan workflow changes by gathering required information. For most cases, prefer sim_build which combines planning and editing in one step.
-
-USE THIS WHEN:
-- You need fine-grained control over the build process
-- You want to inspect the plan before executing it
-
-WORKFLOW ID (REQUIRED):
-- For NEW workflows: First call create_workflow to get a workflowId, then pass it here
-- For EXISTING workflows: Always pass the workflowId parameter
-
-This tool gathers information about available blocks, credentials, and the current workflow state.
-
-RETURNS: A plan object containing block configurations, connections, and technical details.
-IMPORTANT: Pass the returned plan EXACTLY to sim_edit - do not modify or summarize it.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'What you want to build or modify in the workflow.',
-        },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID. For new workflows, call create_workflow first to get this.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-    annotations: { readOnlyHint: true },
-  },
-  {
-    name: 'sim_edit',
-    agentId: 'edit',
-    description: `Execute a workflow plan from sim_plan. For most cases, prefer sim_build which combines planning and editing in one step.
-
-WORKFLOW ID (REQUIRED):
-- You MUST provide the workflowId parameter
-
-PLAN (REQUIRED):
-- Pass the EXACT plan object from sim_plan in the context.plan field
-- Do NOT modify, summarize, or interpret the plan - pass it verbatim
-
-After sim_edit completes, you can test immediately with sim_test, or deploy with sim_deploy to make it accessible externally.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        message: { type: 'string', description: 'Optional additional instructions for the edit.' },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID to edit. Get this from create_workflow for new workflows.',
-        },
-        plan: {
-          type: 'object',
-          description: 'The plan object from sim_plan. Pass it EXACTLY as returned, do not modify.',
-        },
-        context: {
-          type: 'object',
-          description:
-            'Additional context. Put the plan in context.plan if not using the plan field directly.',
-        },
-      },
-      required: ['workflowId'],
-    },
-    annotations: { destructiveHint: false, openWorldHint: true },
-  },
   {
     name: 'sim_deploy',
     agentId: 'deploy',
diff --git a/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
new file mode 100644
index 00000000000..8bf0992a0a0
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
@@ -0,0 +1,47 @@
+import { createLogger } from '@sim/logger'
+import type { ToolExecutionResult, ToolHandler } from '@/lib/copilot/tool-executor/types'
+import { routeExecution } from '@/lib/copilot/tools/server/router'
+
+const logger = createLogger('ServerToolAdapter')
+
+export function createServerToolHandler(toolId: string): ToolHandler {
+  return async (params, context): Promise<ToolExecutionResult> => {
+    const enrichedParams = { ...params }
+    if (!enrichedParams.workflowId && context.workflowId)
+      enrichedParams.workflowId = context.workflowId
+    if (!enrichedParams.workspaceId && context.workspaceId)
+      enrichedParams.workspaceId = context.workspaceId
+
+    try {
+      const result = await routeExecution(toolId, enrichedParams, {
+        userId: context.userId,
+        workspaceId: context.workspaceId,
+        userPermission: context.userPermission ?? undefined,
+        chatId: context.chatId,
+        abortSignal: context.abortSignal,
+      })
+
+      const rec =
+        result && typeof result === 'object' && !Array.isArray(result)
+          ? (result as Record<string, unknown>)
+          : null
+      if (rec?.success === false) {
+        const message =
+          (typeof rec.error === 'string' && rec.error) ||
+          (typeof rec.message === 'string' && rec.message) ||
+          `${toolId} failed`
+        return { success: false, error: message, output: result }
+      }
+      return { success: true, output: result }
+    } catch (error) {
+      logger.error('Server tool execution failed', {
+        toolId,
+        error: error instanceof Error ? error.message : String(error),
+      })
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Server tool execution failed',
+      }
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts b/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
index aec442ceff6..d9063e92116 100644
--- a/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
+++ b/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
@@ -1,9 +1,9 @@
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
 import { createLogger } from '@sim/logger'
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { z } from 'zod'
+import { getCopilotToolDescription } from '@/lib/copilot/tools/descriptions'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
-import { GetBlocksMetadataInput, GetBlocksMetadataResult } from '@/lib/copilot/tools/shared/schemas'
 import { getAllowedIntegrationsFromEnv, isHosted } from '@/lib/core/config/feature-flags'
 import { getServiceAccountProviderForProviderId } from '@/lib/oauth/utils'
 import { registry as blockRegistry } from '@/blocks/registry'
@@ -100,17 +100,20 @@ export interface CopilotBlockMetadata {
   yamlDocumentation?: string
 }
 
+const GetBlocksMetadataInputSchema = z.object({ blockIds: z.array(z.string()).min(1) })
+const GetBlocksMetadataResultSchema = z.object({ metadata: z.record(z.any()) })
+
 export const getBlocksMetadataServerTool: BaseServerTool<
-  ReturnType<typeof GetBlocksMetadataInput.parse>,
-  ReturnType<typeof GetBlocksMetadataResult.parse>
+  z.infer<typeof GetBlocksMetadataInputSchema>,
+  z.infer<typeof GetBlocksMetadataResultSchema>
 > = {
   name: 'get_blocks_metadata',
-  inputSchema: GetBlocksMetadataInput,
-  outputSchema: GetBlocksMetadataResult,
+  inputSchema: GetBlocksMetadataInputSchema,
+  outputSchema: GetBlocksMetadataResultSchema,
   async execute(
-    { blockIds }: ReturnType<typeof GetBlocksMetadataInput.parse>,
+    { blockIds }: z.infer<typeof GetBlocksMetadataInputSchema>,
     context?: { userId: string }
-  ): Promise<ReturnType<typeof GetBlocksMetadataResult.parse>> {
+  ): Promise<z.infer<typeof GetBlocksMetadataResultSchema>> {
     const logger = createLogger('GetBlocksMetadataServerTool')
     logger.debug('Executing get_blocks_metadata', { count: blockIds?.length })
 
@@ -319,7 +322,7 @@ export const getBlocksMetadataServerTool: BaseServerTool<
       transformedResult[blockId] = transformBlockMetadata(metadata)
     }
 
-    return GetBlocksMetadataResult.parse({ metadata: transformedResult })
+    return GetBlocksMetadataResultSchema.parse({ metadata: transformedResult })
   },
 }
 
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts b/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
index bae14cfd80f..043802fbb99 100644
--- a/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
+++ b/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { docsEmbeddings } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { sql } from 'drizzle-orm'
+import { SearchDocumentation } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { generateSearchEmbedding } from '@/lib/knowledge/embeddings'
 
@@ -14,7 +15,7 @@ interface DocsSearchParams {
 const DEFAULT_DOCS_SIMILARITY_THRESHOLD = 0.3
 
 export const searchDocumentationServerTool: BaseServerTool<DocsSearchParams, any> = {
-  name: 'search_documentation',
+  name: SearchDocumentation.id,
   async execute(params: DocsSearchParams): Promise<any> {
     const logger = createLogger('SearchDocumentationServerTool')
     const { query, topK = 10, threshold } = params
diff --git a/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts b/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
index 845aac805b6..dc6b0b2daba 100644
--- a/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { z } from 'zod'
+import { DownloadToWorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -116,7 +117,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
   DownloadToWorkspaceFileArgs,
   DownloadToWorkspaceFileResult
 > = {
-  name: 'download_to_workspace_file',
+  name: DownloadToWorkspaceFile.id,
   inputSchema: DownloadToWorkspaceFileArgsSchema,
   outputSchema: DownloadToWorkspaceFileResultSchema,
 
@@ -124,7 +125,8 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
     params: DownloadToWorkspaceFileArgs,
     context?: ServerToolContext
   ): Promise<DownloadToWorkspaceFileResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       throw new Error('Authentication required')
@@ -176,7 +178,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
         mimeType
       )
 
-      reqLogger.info('Downloaded remote file to workspace', {
+      logger.info('Downloaded remote file to workspace', {
         sourceUrl: params.url,
         fileId: uploaded.id,
         fileName: uploaded.name,
@@ -193,7 +195,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : 'Unknown error'
-      reqLogger.error('Failed to download file to workspace', {
+      logger.error('Failed to download file to workspace', {
         url: params.url,
         error: msg,
       })
diff --git a/apps/sim/lib/copilot/tools/server/files/workspace-file.ts b/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
index 76a0d1fdafe..0a8de23aee9 100644
--- a/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
@@ -1,15 +1,20 @@
 import { createLogger } from '@sim/logger'
+import { WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
-import type { WorkspaceFileArgs, WorkspaceFileResult } from '@/lib/copilot/tools/shared/schemas'
-import { generatePptxFromCode } from '@/lib/execution/pptx-vm'
+import {
+  generateDocxFromCode,
+  generatePdfFromCode,
+  generatePptxFromCode,
+} from '@/lib/execution/doc-vm'
 import {
   deleteWorkspaceFile,
   downloadWorkspaceFile as downloadWsFile,
   getWorkspaceFile,
+  getWorkspaceFileByName,
   renameWorkspaceFile,
   updateWorkspaceFileContent,
   uploadWorkspaceFile,
@@ -18,7 +23,60 @@ import {
 const logger = createLogger('WorkspaceFileServerTool')
 
 const PPTX_MIME = 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+const DOCX_MIME = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+const PDF_MIME = 'application/pdf'
 const PPTX_SOURCE_MIME = 'text/x-pptxgenjs'
+const DOCX_SOURCE_MIME = 'text/x-docxjs'
+const PDF_SOURCE_MIME = 'text/x-pdflibjs'
+
+type WorkspaceFileOperation = 'create' | 'append' | 'update' | 'delete' | 'rename' | 'patch'
+
+type WorkspaceFileTarget =
+  | {
+      kind: 'new_file'
+      fileName: string
+      fileId?: string
+    }
+  | {
+      kind: 'file_id'
+      fileId: string
+      fileName?: string
+    }
+
+type WorkspaceFileEdit =
+  | {
+      strategy: 'search_replace'
+      search: string
+      replace: string
+      replaceAll?: boolean
+    }
+  | {
+      strategy: 'anchored'
+      mode: 'replace_between' | 'insert_after' | 'delete_between'
+      occurrence?: number
+      before_anchor?: string
+      after_anchor?: string
+      start_anchor?: string
+      end_anchor?: string
+      anchor?: string
+      content?: string
+    }
+
+type WorkspaceFileArgs = {
+  operation: WorkspaceFileOperation
+  target?: WorkspaceFileTarget
+  title?: string
+  content?: string
+  contentType?: string
+  newName?: string
+  edit?: WorkspaceFileEdit
+}
+
+type WorkspaceFileResult = {
+  success: boolean
+  message: string
+  data?: Record<string, unknown>
+}
 
 const EXT_TO_MIME: Record<string, string> = {
   '.txt': 'text/plain',
@@ -27,6 +85,8 @@ const EXT_TO_MIME: Record<string, string> = {
   '.json': 'application/json',
   '.csv': 'text/csv',
   '.pptx': PPTX_MIME,
+  '.docx': DOCX_MIME,
+  '.pdf': PDF_MIME,
 }
 
 function inferContentType(fileName: string, explicitType?: string): string {
@@ -44,22 +104,72 @@ function validateFlatWorkspaceFileName(fileName: string): string | null {
   return null
 }
 
+function getDocumentFormatInfo(fileName: string): {
+  isDoc: boolean
+  formatName?: 'PPTX' | 'DOCX' | 'PDF'
+  sourceMime?: string
+  generator?: (code: string, workspaceId: string, signal?: AbortSignal) => Promise<Buffer>
+} {
+  const lowerName = fileName.toLowerCase()
+  if (lowerName.endsWith('.pptx')) {
+    return {
+      isDoc: true,
+      formatName: 'PPTX',
+      sourceMime: PPTX_SOURCE_MIME,
+      generator: generatePptxFromCode,
+    }
+  }
+  if (lowerName.endsWith('.docx')) {
+    return {
+      isDoc: true,
+      formatName: 'DOCX',
+      sourceMime: DOCX_SOURCE_MIME,
+      generator: generateDocxFromCode,
+    }
+  }
+  if (lowerName.endsWith('.pdf')) {
+    return {
+      isDoc: true,
+      formatName: 'PDF',
+      sourceMime: PDF_SOURCE_MIME,
+      generator: generatePdfFromCode,
+    }
+  }
+  return { isDoc: false }
+}
+
 export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, WorkspaceFileResult> = {
-  name: 'workspace_file',
+  name: WorkspaceFile.id,
   async execute(
     params: WorkspaceFileArgs,
     context?: ServerToolContext
   ): Promise<WorkspaceFileResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
-      reqLogger.error('Unauthorized attempt to access workspace files')
+      logger.error('Unauthorized attempt to access workspace files')
       throw new Error('Authentication required')
     }
 
-    const { operation, args = {} } = params
-    const workspaceId =
-      context.workspaceId || ((args as Record<string, unknown>).workspaceId as string | undefined)
+    const raw = params as Record<string, unknown>
+    const nested = raw.args as Record<string, unknown> | undefined
+    const normalized: WorkspaceFileArgs =
+      params.operation && params.target
+        ? params
+        : nested && typeof nested === 'object'
+          ? {
+              operation: (nested.operation ?? raw.operation) as WorkspaceFileOperation,
+              target: (nested.target ?? raw.target) as WorkspaceFileTarget | undefined,
+              title: (nested.title ?? raw.title) as string | undefined,
+              content: (nested.content ?? raw.content) as string | undefined,
+              contentType: (nested.contentType ?? raw.contentType) as string | undefined,
+              newName: (nested.newName ?? raw.newName) as string | undefined,
+              edit: (nested.edit ?? raw.edit) as WorkspaceFileEdit | undefined,
+            }
+          : params
+    const { operation } = normalized
+    const workspaceId = context.workspaceId
 
     if (!workspaceId) {
       return { success: false, message: 'Workspace ID is required' }
@@ -67,44 +177,42 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
 
     try {
       switch (operation) {
-        case 'write': {
-          const fileName = (args as Record<string, unknown>).fileName as string | undefined
-          const content = (args as Record<string, unknown>).content as string | undefined
-          const explicitType = (args as Record<string, unknown>).contentType as string | undefined
-
-          if (!fileName) {
-            return { success: false, message: 'fileName is required for write operation' }
-          }
-          if (content === undefined || content === null) {
-            return { success: false, message: 'content is required for write operation' }
+        case 'create': {
+          const target = normalized.target
+          if (!target || target.kind !== 'new_file') {
+            return {
+              success: false,
+              message: 'create requires target.kind=new_file with target.fileName',
+            }
           }
+
+          const fileName = target.fileName
+          const content = normalized.content ?? ''
+          const explicitType = normalized.contentType
           const fileNameValidationError = validateFlatWorkspaceFileName(fileName)
-          if (fileNameValidationError) {
-            return { success: false, message: fileNameValidationError }
-          }
+          if (fileNameValidationError) return { success: false, message: fileNameValidationError }
 
-          const isPptx = fileName.toLowerCase().endsWith('.pptx')
-          let contentType: string
+          const existingFile = await getWorkspaceFileByName(workspaceId, fileName)
+          if (existingFile) {
+            return { success: false, message: `File "${fileName}" already exists` }
+          }
 
-          if (isPptx) {
-            // Validate the code compiles before storing
+          const docInfo = getDocumentFormatInfo(fileName)
+          let contentType = inferContentType(fileName, explicitType)
+          if (docInfo.isDoc) {
             try {
-              await generatePptxFromCode(content, workspaceId)
+              await docInfo.generator!(content, workspaceId)
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err)
-              reqLogger.error('PPTX code validation failed', { error: msg, fileName })
               return {
                 success: false,
-                message: `PPTX generation failed: ${msg}. Fix the pptxgenjs code and retry.`,
+                message: `${docInfo.formatName} generation failed: ${msg}. Fix the code and retry.`,
               }
             }
-            contentType = PPTX_SOURCE_MIME
-          } else {
-            contentType = inferContentType(fileName, explicitType)
+            contentType = docInfo.sourceMime!
           }
 
           const fileBuffer = Buffer.from(content, 'utf-8')
-
           assertServerToolNotAborted(context)
           const result = await uploadWorkspaceFile(
             workspaceId,
@@ -114,7 +222,7 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
             contentType
           )
 
-          reqLogger.info('Workspace file written via copilot', {
+          logger.info('Workspace file created via copilot', {
             fileId: result.id,
             name: fileName,
             size: fileBuffer.length,
@@ -135,48 +243,129 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           }
         }
 
-        case 'update': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          const content = (args as Record<string, unknown>).content as string | undefined
+        case 'append': {
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'append requires target.kind=file_id with target.fileId',
+            }
+          }
+          if (normalized.content === undefined || normalized.content === null) {
+            return { success: false, message: 'content is required for append operation' }
+          }
+
+          const existingFile = await getWorkspaceFile(workspaceId, target.fileId)
+          if (!existingFile) {
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
+          }
+          if (target.fileName && target.fileName !== existingFile.name) {
+            return {
+              success: false,
+              message: `Target mismatch: fileId "${target.fileId}" is "${existingFile.name}", not "${target.fileName}"`,
+            }
+          }
+
+          const docInfo = getDocumentFormatInfo(existingFile.name)
+          const currentBuffer = await downloadWsFile(existingFile)
+          const combined = docInfo.isDoc
+            ? `${currentBuffer.toString('utf-8')}\n{\n${normalized.content}\n}`
+            : `${currentBuffer.toString('utf-8')}\n${normalized.content}`
+
+          if (docInfo.isDoc) {
+            try {
+              await docInfo.generator!(combined, workspaceId)
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err)
+              return {
+                success: false,
+                message: `${docInfo.formatName} generation failed after append: ${msg}. Fix the content and retry.`,
+              }
+            }
+          }
+
+          const combinedBuffer = Buffer.from(combined, 'utf-8')
+          assertServerToolNotAborted(context)
+          const appendMime =
+            docInfo.sourceMime || inferContentType(existingFile.name, normalized.contentType)
+          await updateWorkspaceFileContent(
+            workspaceId,
+            existingFile.id,
+            context.userId,
+            combinedBuffer,
+            appendMime
+          )
+
+          logger.info('Workspace file appended via copilot', {
+            fileId: existingFile.id,
+            name: existingFile.name,
+            appendedSize: normalized.content.length,
+            totalSize: combinedBuffer.length,
+            userId: context.userId,
+          })
 
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for update operation' }
+          return {
+            success: true,
+            message: `Content appended to "${existingFile.name}" (${normalized.content.length} bytes added, ${combinedBuffer.length} bytes total)`,
+            data: {
+              id: existingFile.id,
+              name: existingFile.name,
+              size: combinedBuffer.length,
+              contentType: appendMime,
+            },
           }
-          if (content === undefined || content === null) {
+        }
+
+        case 'update': {
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'update requires target.kind=file_id with target.fileId',
+            }
+          }
+          if (normalized.content === undefined || normalized.content === null) {
             return { success: false, message: 'content is required for update operation' }
           }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
+          }
+          if (target.fileName && target.fileName !== fileRecord.name) {
+            return {
+              success: false,
+              message: `Target mismatch: fileId "${target.fileId}" is "${fileRecord.name}", not "${target.fileName}"`,
+            }
           }
 
-          const isPptxUpdate = fileRecord.name?.toLowerCase().endsWith('.pptx')
-          if (isPptxUpdate) {
+          const docInfo = getDocumentFormatInfo(fileRecord.name)
+          if (docInfo.isDoc) {
             try {
-              await generatePptxFromCode(content, workspaceId)
+              await docInfo.generator!(normalized.content, workspaceId)
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err)
               return {
                 success: false,
-                message: `PPTX generation failed: ${msg}. Fix the pptxgenjs code and retry.`,
+                message: `${docInfo.formatName} generation failed: ${msg}. Fix the code and retry.`,
               }
             }
           }
 
-          const fileBuffer = Buffer.from(content, 'utf-8')
-
+          const fileBuffer = Buffer.from(normalized.content, 'utf-8')
           assertServerToolNotAborted(context)
+          const updateMime =
+            docInfo.sourceMime || inferContentType(fileRecord.name, normalized.contentType)
           await updateWorkspaceFileContent(
             workspaceId,
-            fileId,
+            target.fileId,
             context.userId,
             fileBuffer,
-            isPptxUpdate ? PPTX_SOURCE_MIME : undefined
+            updateMime
           )
 
-          reqLogger.info('Workspace file updated via copilot', {
-            fileId,
+          logger.info('Workspace file updated via copilot', {
+            fileId: target.fileId,
             name: fileRecord.name,
             size: fileBuffer.length,
             userId: context.userId,
@@ -186,67 +375,70 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
             success: true,
             message: `File "${fileRecord.name}" updated successfully (${fileBuffer.length} bytes)`,
             data: {
-              id: fileId,
+              id: target.fileId,
               name: fileRecord.name,
               size: fileBuffer.length,
+              contentType: updateMime,
             },
           }
         }
 
         case 'rename': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          const newName = (args as Record<string, unknown>).newName as string | undefined
-
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for rename operation' }
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'rename requires target.kind=file_id with target.fileId',
+            }
           }
-          if (!newName) {
+          if (!normalized.newName) {
             return { success: false, message: 'newName is required for rename operation' }
           }
-          const fileNameValidationError = validateFlatWorkspaceFileName(newName)
-          if (fileNameValidationError) {
-            return { success: false, message: fileNameValidationError }
-          }
+          const fileNameValidationError = validateFlatWorkspaceFileName(normalized.newName)
+          if (fileNameValidationError) return { success: false, message: fileNameValidationError }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
 
           const oldName = fileRecord.name
           assertServerToolNotAborted(context)
-          await renameWorkspaceFile(workspaceId, fileId, newName)
+          await renameWorkspaceFile(workspaceId, target.fileId, normalized.newName)
 
-          reqLogger.info('Workspace file renamed via copilot', {
-            fileId,
+          logger.info('Workspace file renamed via copilot', {
+            fileId: target.fileId,
             oldName,
-            newName,
+            newName: normalized.newName,
             userId: context.userId,
           })
 
           return {
             success: true,
-            message: `File renamed from "${oldName}" to "${newName}"`,
-            data: { id: fileId, name: newName },
+            message: `File renamed from "${oldName}" to "${normalized.newName}"`,
+            data: { id: target.fileId, name: normalized.newName },
           }
         }
 
         case 'delete': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for delete operation' }
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'delete requires target.kind=file_id with target.fileId',
+            }
           }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
 
           assertServerToolNotAborted(context)
-          await deleteWorkspaceFile(workspaceId, fileId)
+          await deleteWorkspaceFile(workspaceId, target.fileId)
 
-          reqLogger.info('Workspace file deleted via copilot', {
-            fileId,
+          logger.info('Workspace file deleted via copilot', {
+            fileId: target.fileId,
             name: fileRecord.name,
             userId: context.userId,
           })
@@ -254,88 +446,188 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           return {
             success: true,
             message: `File "${fileRecord.name}" deleted successfully`,
-            data: { id: fileId, name: fileRecord.name },
+            data: { id: target.fileId, name: fileRecord.name },
           }
         }
 
         case 'patch': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          const edits = (args as Record<string, unknown>).edits as
-            | { search: string; replace: string }[]
-            | undefined
-
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for patch operation' }
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'patch requires target.kind=file_id with target.fileId',
+            }
           }
-          if (!edits || !Array.isArray(edits) || edits.length === 0) {
-            return { success: false, message: 'edits array is required for patch operation' }
+          if (!normalized.edit) {
+            return { success: false, message: 'edit is required for patch operation' }
           }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
 
           const currentBuffer = await downloadWsFile(fileRecord)
           let content = currentBuffer.toString('utf-8')
 
-          for (const edit of edits) {
-            const firstIdx = content.indexOf(edit.search)
+          if (normalized.edit.strategy === 'anchored') {
+            const lines = content.split('\n')
+            const defaultOccurrence = normalized.edit.occurrence ?? 1
+
+            const findAnchorLine = (
+              anchor: string,
+              occurrence = defaultOccurrence,
+              afterIndex = -1
+            ): { index: number; error?: string } => {
+              const trimmed = anchor.trim()
+              let count = 0
+              for (let i = afterIndex + 1; i < lines.length; i++) {
+                if (lines[i].trim() === trimmed) {
+                  count++
+                  if (count === occurrence) return { index: i }
+                }
+              }
+              if (count === 0) {
+                return {
+                  index: -1,
+                  error: `Anchor line not found in "${fileRecord.name}": "${anchor.slice(0, 100)}"`,
+                }
+              }
+              return {
+                index: -1,
+                error: `Anchor line occurrence ${occurrence} not found (only ${count} match${count > 1 ? 'es' : ''}) in "${fileRecord.name}": "${anchor.slice(0, 100)}"`,
+              }
+            }
+
+            if (normalized.edit.mode === 'replace_between') {
+              if (!normalized.edit.before_anchor || !normalized.edit.after_anchor) {
+                return {
+                  success: false,
+                  message: 'replace_between requires before_anchor and after_anchor',
+                }
+              }
+              const before = findAnchorLine(normalized.edit.before_anchor)
+              if (before.error) return { success: false, message: `Patch failed: ${before.error}` }
+              const after = findAnchorLine(
+                normalized.edit.after_anchor,
+                defaultOccurrence,
+                before.index
+              )
+              if (after.error) return { success: false, message: `Patch failed: ${after.error}` }
+              if (after.index <= before.index) {
+                return {
+                  success: false,
+                  message: 'Patch failed: after_anchor must appear after before_anchor in the file',
+                }
+              }
+              const newLines = [
+                ...lines.slice(0, before.index + 1),
+                ...(normalized.edit.content ?? '').split('\n'),
+                ...lines.slice(after.index),
+              ]
+              content = newLines.join('\n')
+            } else if (normalized.edit.mode === 'insert_after') {
+              if (!normalized.edit.anchor) {
+                return { success: false, message: 'insert_after requires anchor' }
+              }
+              const found = findAnchorLine(normalized.edit.anchor)
+              if (found.error) return { success: false, message: `Patch failed: ${found.error}` }
+              const newLines = [
+                ...lines.slice(0, found.index + 1),
+                ...(normalized.edit.content ?? '').split('\n'),
+                ...lines.slice(found.index + 1),
+              ]
+              content = newLines.join('\n')
+            } else if (normalized.edit.mode === 'delete_between') {
+              if (!normalized.edit.start_anchor || !normalized.edit.end_anchor) {
+                return {
+                  success: false,
+                  message: 'delete_between requires start_anchor and end_anchor',
+                }
+              }
+              const start = findAnchorLine(normalized.edit.start_anchor)
+              if (start.error) return { success: false, message: `Patch failed: ${start.error}` }
+              const end = findAnchorLine(normalized.edit.end_anchor, defaultOccurrence, start.index)
+              if (end.error) return { success: false, message: `Patch failed: ${end.error}` }
+              if (end.index <= start.index) {
+                return {
+                  success: false,
+                  message: 'Patch failed: end_anchor must appear after start_anchor in the file',
+                }
+              }
+              const newLines = [...lines.slice(0, start.index), ...lines.slice(end.index)]
+              content = newLines.join('\n')
+            } else {
+              return {
+                success: false,
+                message: `Unknown anchored patch mode: "${normalized.edit.mode}"`,
+              }
+            }
+          } else if (normalized.edit.strategy === 'search_replace') {
+            const search = normalized.edit.search
+            const replace = normalized.edit.replace
+            const firstIdx = content.indexOf(search)
             if (firstIdx === -1) {
               return {
                 success: false,
-                message: `Patch failed: search string not found in file "${fileRecord.name}". Search: "${edit.search.slice(0, 100)}${edit.search.length > 100 ? '...' : ''}"`,
+                message: `Patch failed: search string not found in file "${fileRecord.name}". Search: "${search.slice(0, 100)}${search.length > 100 ? '...' : ''}"`,
               }
             }
-            if (content.indexOf(edit.search, firstIdx + 1) !== -1) {
+            if (!normalized.edit.replaceAll && content.indexOf(search, firstIdx + 1) !== -1) {
               return {
                 success: false,
-                message: `Patch failed: search string is ambiguous — found at multiple locations in "${fileRecord.name}". Use a longer, unique search string.`,
+                message: `Patch failed: search string is ambiguous — found at multiple locations in "${fileRecord.name}". Use a longer unique search string or replaceAll.`,
               }
             }
-            content =
-              content.slice(0, firstIdx) +
-              edit.replace +
-              content.slice(firstIdx + edit.search.length)
+            content = normalized.edit.replaceAll
+              ? content.split(search).join(replace)
+              : content.slice(0, firstIdx) + replace + content.slice(firstIdx + search.length)
+          } else {
+            return {
+              success: false,
+              message: `Unknown patch strategy: "${(normalized.edit as { strategy?: string }).strategy}"`,
+            }
           }
 
-          const isPptxPatch = fileRecord.name?.toLowerCase().endsWith('.pptx')
-          if (isPptxPatch) {
+          const docInfo = getDocumentFormatInfo(fileRecord.name)
+          if (docInfo.isDoc) {
             try {
-              await generatePptxFromCode(content, workspaceId)
+              await docInfo.generator!(content, workspaceId)
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err)
               return {
                 success: false,
-                message: `Patched PPTX code failed to compile: ${msg}. Fix the edits and retry.`,
+                message: `Patched ${docInfo.formatName} code failed to compile: ${msg}. Fix the edit and retry.`,
               }
             }
           }
 
           const patchedBuffer = Buffer.from(content, 'utf-8')
           assertServerToolNotAborted(context)
+          const patchMime = docInfo.sourceMime || inferContentType(fileRecord.name)
           await updateWorkspaceFileContent(
             workspaceId,
-            fileId,
+            target.fileId,
             context.userId,
             patchedBuffer,
-            isPptxPatch ? PPTX_SOURCE_MIME : undefined
+            patchMime
           )
 
-          reqLogger.info('Workspace file patched via copilot', {
-            fileId,
+          logger.info('Workspace file patched via copilot', {
+            fileId: target.fileId,
             name: fileRecord.name,
-            editCount: edits.length,
+            strategy: normalized.edit.strategy,
             userId: context.userId,
           })
 
           return {
             success: true,
-            message: `File "${fileRecord.name}" patched successfully (${edits.length} edit${edits.length > 1 ? 's' : ''} applied)`,
+            message: `File "${fileRecord.name}" patched successfully (${normalized.edit.strategy} edit applied)`,
             data: {
-              id: fileId,
+              id: target.fileId,
               name: fileRecord.name,
               size: patchedBuffer.length,
+              contentType: patchMime,
             },
           }
         }
@@ -343,12 +635,12 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
         default:
           return {
             success: false,
-            message: `Unknown operation: ${operation}. Supported: write, update, patch, rename, delete.`,
+            message: `Unknown operation: ${operation}. Supported: create, append, update, patch, rename, delete.`,
           }
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'
-      reqLogger.error('Error in workspace_file tool', {
+      logger.error('Error in workspace_file tool', {
         operation,
         error: errorMessage,
         userId: context.userId,
diff --git a/apps/sim/lib/copilot/tools/server/generated-schema.ts b/apps/sim/lib/copilot/tools/server/generated-schema.ts
new file mode 100644
index 00000000000..579e969efa7
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/generated-schema.ts
@@ -0,0 +1,49 @@
+import Ajv, { type ErrorObject, type ValidateFunction } from 'ajv'
+import { TOOL_RUNTIME_SCHEMAS } from '@/lib/copilot/generated/tool-schemas-v1'
+
+const ajv = new Ajv({
+  allErrors: true,
+  strict: false,
+})
+
+const validatorCache = new Map<string, ValidateFunction>()
+
+function formatErrors(errors: ErrorObject[] | null | undefined): string {
+  if (!errors || errors.length === 0) return 'unknown validation error'
+  return errors
+    .slice(0, 5)
+    .map((error) => `${error.instancePath || '/'} ${error.message || 'is invalid'}`.trim())
+    .join('; ')
+}
+
+function getValidator(
+  toolName: string,
+  schemaKind: 'parameters' | 'resultSchema'
+): ValidateFunction | null {
+  const cacheKey = `${toolName}:${schemaKind}`
+  const cached = validatorCache.get(cacheKey)
+  if (cached) return cached
+
+  const schema = TOOL_RUNTIME_SCHEMAS[toolName]?.[schemaKind]
+  if (!schema) return null
+
+  const validator = ajv.compile(schema as object)
+  validatorCache.set(cacheKey, validator)
+  return validator
+}
+
+export function validateGeneratedToolPayload<T>(
+  toolName: string,
+  schemaKind: 'parameters' | 'resultSchema',
+  payload: T
+): T {
+  const validator = getValidator(toolName, schemaKind)
+  if (!validator) return payload
+
+  if (!validator(payload)) {
+    const label = schemaKind === 'parameters' ? 'input' : 'output'
+    throw new Error(`${toolName} ${label} validation failed: ${formatErrors(validator.errors)}`)
+  }
+
+  return payload
+}
diff --git a/apps/sim/lib/copilot/tools/server/image/generate-image.ts b/apps/sim/lib/copilot/tools/server/image/generate-image.ts
index 283ac69f92c..d1ccfee0362 100644
--- a/apps/sim/lib/copilot/tools/server/image/generate-image.ts
+++ b/apps/sim/lib/copilot/tools/server/image/generate-image.ts
@@ -1,5 +1,6 @@
 import { GoogleGenAI, type Part } from '@google/genai'
 import { createLogger } from '@sim/logger'
+import { GenerateImage } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -54,13 +55,14 @@ interface GenerateImageResult {
 }
 
 export const generateImageServerTool: BaseServerTool<GenerateImageArgs, GenerateImageResult> = {
-  name: 'generate_image',
+  name: GenerateImage.id,
 
   async execute(
     params: GenerateImageArgs,
     context?: ServerToolContext
   ): Promise<GenerateImageResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       throw new Error('Authentication required')
@@ -95,17 +97,17 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
               parts.push({
                 inlineData: { mimeType: mime, data: base64 },
               })
-              reqLogger.info('Loaded reference image', {
+              logger.info('Loaded reference image', {
                 fileId,
                 name: fileRecord.name,
                 size: buffer.length,
                 mimeType: mime,
               })
             } else {
-              reqLogger.warn('Reference file not found, skipping', { fileId })
+              logger.warn('Reference file not found, skipping', { fileId })
             }
           } catch (err) {
-            reqLogger.warn('Failed to load reference image, skipping', {
+            logger.warn('Failed to load reference image, skipping', {
               fileId,
               error: err instanceof Error ? err.message : String(err),
             })
@@ -119,7 +121,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
 
       parts.push({ text: prompt + sizeInstruction })
 
-      reqLogger.info('Generating image with Nano Banana 2', {
+      logger.info('Generating image with Nano Banana 2', {
         model: NANO_BANANA_MODEL,
         aspectRatio,
         promptLength: prompt.length,
@@ -184,7 +186,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
           imageBuffer,
           mimeType
         )
-        reqLogger.info('Generated image overwritten', {
+        logger.info('Generated image overwritten', {
           fileId: updated.id,
           fileName: updated.name,
           size: imageBuffer.length,
@@ -210,7 +212,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
         mimeType
       )
 
-      reqLogger.info('Generated image saved', {
+      logger.info('Generated image saved', {
         fileId: uploaded.id,
         fileName: uploaded.name,
         size: imageBuffer.length,
@@ -227,7 +229,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : 'Unknown error'
-      reqLogger.error('Image generation failed', { error: msg })
+      logger.error('Image generation failed', { error: msg })
       return { success: false, message: `Failed to generate image: ${msg}` }
     }
   },
diff --git a/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts b/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts
index 76f01c70f59..90ed8fbbe51 100644
--- a/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts
+++ b/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { jobExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
+import { GetJobLogs } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
 import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -83,9 +84,10 @@ function extractOutputAndError(executionData: any): {
 }
 
 export const getJobLogsServerTool: BaseServerTool<GetJobLogsArgs, JobLogEntry[]> = {
-  name: 'get_job_logs',
+  name: GetJobLogs.id,
   async execute(rawArgs: GetJobLogsArgs, context?: ServerToolContext): Promise<JobLogEntry[]> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     const {
       jobId,
@@ -112,7 +114,7 @@ export const getJobLogsServerTool: BaseServerTool<GetJobLogsArgs, JobLogEntry[]>
 
     const clampedLimit = Math.min(Math.max(1, limit), 5)
 
-    reqLogger.info('Fetching job logs', {
+    logger.info('Fetching job logs', {
       jobId,
       executionId,
       limit: clampedLimit,
@@ -171,7 +173,7 @@ export const getJobLogsServerTool: BaseServerTool<GetJobLogsArgs, JobLogEntry[]>
       return entry
     })
 
-    reqLogger.info('Job logs prepared', {
+    logger.info('Job logs prepared', {
       jobId,
       count: entries.length,
       resultSizeKB: Math.round(JSON.stringify(entries).length / 1024),
diff --git a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
index 5cc6538025d..b34fc6552d4 100644
--- a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
+++ b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
@@ -3,12 +3,12 @@ import { knowledgeConnector } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, isNull } from 'drizzle-orm'
 import { generateInternalToken } from '@/lib/auth/internal'
+import { KnowledgeBase } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
-import type { KnowledgeBaseArgs, KnowledgeBaseResult } from '@/lib/copilot/tools/shared/schemas'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { generateId } from '@/lib/core/utils/uuid'
 import {
@@ -39,21 +39,31 @@ import { getQueryStrategy, handleVectorOnlySearch } from '@/app/api/knowledge/se
 
 const logger = createLogger('KnowledgeBaseServerTool')
 
+type KnowledgeBaseArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type KnowledgeBaseResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
 /**
  * Knowledge base tool for copilot to create, list, and get knowledge bases
  */
 export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, KnowledgeBaseResult> = {
-  name: 'knowledge_base',
+  name: KnowledgeBase.id,
   async execute(
     params: KnowledgeBaseArgs,
     context?: ServerToolContext
   ): Promise<KnowledgeBaseResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
-      reqLogger.error(
-        'Unauthorized attempt to access knowledge base - no authenticated user context'
-      )
+      logger.error('Unauthorized attempt to access knowledge base - no authenticated user context')
       throw new Error('Authentication required')
     }
 
@@ -102,7 +112,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             requestId
           )
 
-          reqLogger.info('Knowledge base created via copilot', {
+          logger.info('Knowledge base created via copilot', {
             knowledgeBaseId: newKnowledgeBase.id,
             name: newKnowledgeBase.name,
             userId: context.userId,
@@ -138,7 +148,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             }
           }
 
-          reqLogger.info('Knowledge base metadata retrieved via copilot', {
+          logger.info('Knowledge base metadata retrieved via copilot', {
             knowledgeBaseId: knowledgeBase.id,
             userId: context.userId,
           })
@@ -202,7 +212,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             distanceThreshold: strategy.distanceThreshold,
           })
 
-          reqLogger.info('Knowledge base queried via copilot', {
+          logger.info('Knowledge base queried via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             query: args.query.substring(0, 100),
             resultCount: results.length,
@@ -293,13 +303,13 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             },
             {}
           ).catch((err) => {
-            reqLogger.error('Background document processing failed', {
+            logger.error('Background document processing failed', {
               documentId: doc.id,
               error: err instanceof Error ? err.message : String(err),
             })
           })
 
-          reqLogger.info('Workspace file added to knowledge base via copilot', {
+          logger.info('Workspace file added to knowledge base via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             documentId: doc.id,
             fileName: fileRecord.name,
@@ -349,7 +359,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           assertNotAborted()
           const updatedKb = await updateKnowledgeBase(args.knowledgeBaseId, updates, requestId)
 
-          reqLogger.info('Knowledge base updated via copilot', {
+          logger.info('Knowledge base updated via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             userId: context.userId,
           })
@@ -388,7 +398,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           assertNotAborted()
           await deleteKnowledgeBase(args.knowledgeBaseId, requestId)
 
-          reqLogger.info('Knowledge base deleted via copilot', {
+          logger.info('Knowledge base deleted via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             name: kbToDelete.name,
             userId: context.userId,
@@ -465,7 +475,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
 
           const tagDefinitions = await getDocumentTagDefinitions(args.knowledgeBaseId)
 
-          reqLogger.info('Tag definitions listed via copilot', {
+          logger.info('Tag definitions listed via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             count: tagDefinitions.length,
             userId: context.userId,
@@ -519,7 +529,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             requestId
           )
 
-          reqLogger.info('Tag definition created via copilot', {
+          logger.info('Tag definition created via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             tagId: newTag.id,
             displayName: newTag.displayName,
@@ -570,7 +580,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           assertNotAborted()
           const updatedTag = await updateTagDefinition(args.tagDefinitionId, updateData, requestId)
 
-          reqLogger.info('Tag definition updated via copilot', {
+          logger.info('Tag definition updated via copilot', {
             tagId: args.tagDefinitionId,
             knowledgeBaseId: existingTag.knowledgeBaseId,
             userId: context.userId,
@@ -611,7 +621,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             requestId
           )
 
-          reqLogger.info('Tag definition deleted via copilot', {
+          logger.info('Tag definition deleted via copilot', {
             tagId: args.tagDefinitionId,
             tagSlot: deleted.tagSlot,
             displayName: deleted.displayName,
@@ -693,7 +703,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           }
 
           const connector = createRes.data
-          reqLogger.info('Connector created via copilot', {
+          logger.info('Connector created via copilot', {
             connectorId: connector.id,
             connectorType: args.connectorType,
             knowledgeBaseId: args.knowledgeBaseId,
@@ -748,7 +758,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             return { success: false, message: updateRes.error ?? 'Failed to update connector' }
           }
 
-          reqLogger.info('Connector updated via copilot', {
+          logger.info('Connector updated via copilot', {
             connectorId: args.connectorId,
             userId: context.userId,
           })
@@ -781,7 +791,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             return { success: false, message: deleteRes.error ?? 'Failed to delete connector' }
           }
 
-          reqLogger.info('Connector deleted via copilot', {
+          logger.info('Connector deleted via copilot', {
             connectorId: args.connectorId,
             userId: context.userId,
           })
@@ -814,7 +824,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             return { success: false, message: syncRes.error ?? 'Failed to sync connector' }
           }
 
-          reqLogger.info('Connector sync triggered via copilot', {
+          logger.info('Connector sync triggered via copilot', {
             connectorId: args.connectorId,
             userId: context.userId,
           })
@@ -834,7 +844,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'
-      reqLogger.error('Error in knowledge_base tool', {
+      logger.error('Error in knowledge_base tool', {
         operation,
         error: errorMessage,
         userId: context.userId,
diff --git a/apps/sim/lib/copilot/tools/server/other/make-api-request.ts b/apps/sim/lib/copilot/tools/server/other/make-api-request.ts
deleted file mode 100644
index 3f95460511a..00000000000
--- a/apps/sim/lib/copilot/tools/server/other/make-api-request.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
-import { executeTool } from '@/tools'
-import type { TableRow } from '@/tools/types'
-
-const RESULT_CHAR_CAP = Number(process.env.COPILOT_TOOL_RESULT_CHAR_CAP || 20000)
-
-interface MakeApiRequestParams {
-  url: string
-  method: 'GET' | 'POST' | 'PUT'
-  queryParams?: Record<string, string | number | boolean>
-  headers?: Record<string, string>
-  body?: unknown
-}
-
-interface ApiResponse {
-  data: string
-  status: number
-  headers: Record<string, string>
-  truncated?: boolean
-  totalChars?: number
-  previewChars?: number
-  note?: string
-}
-
-export const makeApiRequestServerTool: BaseServerTool<MakeApiRequestParams, ApiResponse> = {
-  name: 'make_api_request',
-  async execute(params: MakeApiRequestParams): Promise<ApiResponse> {
-    const logger = createLogger('MakeApiRequestServerTool')
-    const { url, method, queryParams, headers, body } = params
-    if (!url || !method) throw new Error('url and method are required')
-
-    const toTableRows = (obj?: Record<string, unknown>): TableRow[] | null => {
-      if (!obj || typeof obj !== 'object') return null
-      return Object.entries(obj).map(([key, value]) => ({
-        id: key,
-        cells: { Key: key, Value: value },
-      }))
-    }
-    const headersTable = toTableRows(headers)
-    const queryParamsTable = toTableRows(queryParams as Record<string, unknown> | undefined)
-
-    const result = await executeTool(
-      'http_request',
-      { url, method, params: queryParamsTable, headers: headersTable, body },
-      true
-    )
-    if (!result.success) throw new Error(result.error ?? 'API request failed')
-
-    const output = result.output as Record<string, unknown> | undefined
-    const nestedOutput = output?.output as Record<string, unknown> | undefined
-    const data = nestedOutput?.data ?? output?.data
-    const status = (nestedOutput?.status ?? output?.status ?? 200) as number
-    const respHeaders = (nestedOutput?.headers ?? output?.headers ?? {}) as Record<string, string>
-
-    const toStringSafe = (val: unknown): string => {
-      if (typeof val === 'string') return val
-      try {
-        return JSON.stringify(val)
-      } catch {
-        return String(val)
-      }
-    }
-
-    const stripHtml = (html: string): string => {
-      try {
-        let text = html
-        let previous: string
-        do {
-          previous = text
-          text = text.replace(/<script[\s\S]*?<\/script\s*>/gi, '')
-          text = text.replace(/<style[\s\S]*?<\/style\s*>/gi, '')
-          text = text.replace(/<[^>]*>/g, ' ')
-          text = text.replace(/[<>]/g, ' ')
-        } while (text !== previous)
-        return text.replace(/\s+/g, ' ').trim()
-      } catch {
-        return html
-      }
-    }
-
-    let normalized = toStringSafe(data)
-    const looksLikeHtml =
-      /<html[\s\S]*<\/html>/i.test(normalized) || /<body[\s\S]*<\/body>/i.test(normalized)
-    if (looksLikeHtml) normalized = stripHtml(normalized)
-
-    const totalChars = normalized.length
-    if (totalChars > RESULT_CHAR_CAP) {
-      const preview = normalized.slice(0, RESULT_CHAR_CAP)
-      logger.warn('API response truncated', { url, method, totalChars, cap: RESULT_CHAR_CAP })
-      return {
-        data: preview,
-        status,
-        headers: respHeaders,
-        truncated: true,
-        totalChars,
-        previewChars: preview.length,
-        note: `Response truncated to ${RESULT_CHAR_CAP} characters`,
-      }
-    }
-
-    logger.debug('API request executed', { url, method, status, totalChars })
-    return { data: normalized, status, headers: respHeaders }
-  },
-}
diff --git a/apps/sim/lib/copilot/tools/server/other/search-online.ts b/apps/sim/lib/copilot/tools/server/other/search-online.ts
index 75f59b507f8..f9a50956f77 100644
--- a/apps/sim/lib/copilot/tools/server/other/search-online.ts
+++ b/apps/sim/lib/copilot/tools/server/other/search-online.ts
@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { SearchOnline } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { env } from '@/lib/core/config/env'
 import { executeTool } from '@/tools'
@@ -28,7 +29,7 @@ interface SearchResponse {
 }
 
 export const searchOnlineServerTool: BaseServerTool<OnlineSearchParams, SearchResponse> = {
-  name: 'search_online',
+  name: SearchOnline.id,
   async execute(params: OnlineSearchParams): Promise<SearchResponse> {
     const logger = createLogger('SearchOnlineServerTool')
     const { query, num = 10, type = 'search', gl, hl } = params
diff --git a/apps/sim/lib/copilot/tools/server/router.ts b/apps/sim/lib/copilot/tools/server/router.ts
index 18dfdc7deb0..cd18e19c48f 100644
--- a/apps/sim/lib/copilot/tools/server/router.ts
+++ b/apps/sim/lib/copilot/tools/server/router.ts
@@ -1,4 +1,17 @@
 import { createLogger } from '@sim/logger'
+import { z } from 'zod'
+import {
+  DownloadToWorkspaceFile,
+  GenerateImage,
+  GenerateVisualization,
+  KnowledgeBase,
+  ManageCredential,
+  ManageCustomTool,
+  ManageMcpTool,
+  ManageSkill,
+  UserTable,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -9,10 +22,10 @@ import { getTriggerBlocksServerTool } from '@/lib/copilot/tools/server/blocks/ge
 import { searchDocumentationServerTool } from '@/lib/copilot/tools/server/docs/search-documentation'
 import { downloadToWorkspaceFileServerTool } from '@/lib/copilot/tools/server/files/download-to-workspace-file'
 import { workspaceFileServerTool } from '@/lib/copilot/tools/server/files/workspace-file'
+import { validateGeneratedToolPayload } from '@/lib/copilot/tools/server/generated-schema'
 import { generateImageServerTool } from '@/lib/copilot/tools/server/image/generate-image'
 import { getJobLogsServerTool } from '@/lib/copilot/tools/server/jobs/get-job-logs'
 import { knowledgeBaseServerTool } from '@/lib/copilot/tools/server/knowledge/knowledge-base'
-import { makeApiRequestServerTool } from '@/lib/copilot/tools/server/other/make-api-request'
 import { searchOnlineServerTool } from '@/lib/copilot/tools/server/other/search-online'
 import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
 import { getCredentialsServerTool } from '@/lib/copilot/tools/server/user/get-credentials'
@@ -21,15 +34,19 @@ import { generateVisualizationServerTool } from '@/lib/copilot/tools/server/visu
 import { editWorkflowServerTool } from '@/lib/copilot/tools/server/workflow/edit-workflow'
 import { getExecutionSummaryServerTool } from '@/lib/copilot/tools/server/workflow/get-execution-summary'
 import { getWorkflowLogsServerTool } from '@/lib/copilot/tools/server/workflow/get-workflow-logs'
-import { ExecuteResponseSuccessSchema } from '@/lib/copilot/tools/shared/schemas'
 
 export { ExecuteResponseSuccessSchema }
 export type ExecuteResponseSuccess = (typeof ExecuteResponseSuccessSchema)['_type']
 
+const ExecuteResponseSuccessSchema = z.object({
+  success: z.literal(true),
+  result: z.unknown(),
+})
+
 const logger = createLogger('ServerToolRouter')
 
 const WRITE_ACTIONS: Record<string, string[]> = {
-  knowledge_base: [
+  [KnowledgeBase.id]: [
     'create',
     'add_file',
     'update',
@@ -44,7 +61,7 @@ const WRITE_ACTIONS: Record<string, string[]> = {
     'delete_connector',
     'sync_connector',
   ],
-  user_table: [
+  [UserTable.id]: [
     'create',
     'create_from_file',
     'import_file',
@@ -60,14 +77,14 @@ const WRITE_ACTIONS: Record<string, string[]> = {
     'delete_column',
     'update_column',
   ],
-  manage_custom_tool: ['add', 'edit', 'delete'],
-  manage_mcp_tool: ['add', 'edit', 'delete'],
-  manage_skill: ['add', 'edit', 'delete'],
-  manage_credential: ['rename', 'delete'],
-  workspace_file: ['write', 'update', 'delete', 'rename', 'patch'],
-  download_to_workspace_file: ['*'],
-  generate_visualization: ['generate'],
-  generate_image: ['generate'],
+  [ManageCustomTool.id]: ['add', 'edit', 'delete'],
+  [ManageMcpTool.id]: ['add', 'edit', 'delete'],
+  [ManageSkill.id]: ['add', 'edit', 'delete'],
+  [ManageCredential.id]: ['rename', 'delete'],
+  [WorkspaceFile.id]: ['create', 'append', 'update', 'delete', 'rename', 'patch'],
+  [DownloadToWorkspaceFile.id]: ['*'],
+  [GenerateVisualization.id]: ['generate'],
+  [GenerateImage.id]: ['generate'],
 }
 
 function isWritePermission(userPermission: string): boolean {
@@ -99,7 +116,6 @@ const serverToolRegistry: Record<string, BaseServerTool> = {
   [searchOnlineServerTool.name]: searchOnlineServerTool,
   [setEnvironmentVariablesServerTool.name]: setEnvironmentVariablesServerTool,
   [getCredentialsServerTool.name]: getCredentialsServerTool,
-  [makeApiRequestServerTool.name]: makeApiRequestServerTool,
   [knowledgeBaseServerTool.name]: knowledgeBaseServerTool,
   [userTableServerTool.name]: userTableServerTool,
   [workspaceFileServerTool.name]: workspaceFileServerTool,
@@ -108,10 +124,10 @@ const serverToolRegistry: Record<string, BaseServerTool> = {
   [generateImageServerTool.name]: generateImageServerTool,
 }
 
-/**
- * Route a tool execution request to the appropriate server tool.
- * Validates input/output using the tool's declared Zod schemas if present.
- */
+export function getRegisteredServerToolNames(): string[] {
+  return Object.keys(serverToolRegistry)
+}
+
 export async function routeExecution(
   toolName: string,
   payload: unknown,
@@ -122,9 +138,10 @@ export async function routeExecution(
     throw new Error(`Unknown server tool: ${toolName}`)
   }
 
-  logger.withMetadata({ messageId: context?.messageId }).debug('Routing to tool', {
-    toolName,
-  })
+  logger.debug(
+    context?.messageId ? `Routing to tool [messageId:${context.messageId}]` : 'Routing to tool',
+    { toolName }
+  )
 
   // Action-level permission enforcement for mixed read/write tools
   if (context?.userPermission && WRITE_ACTIONS[toolName]) {
@@ -140,14 +157,34 @@ export async function routeExecution(
 
   assertServerToolNotAborted(context)
 
-  // Validate input if tool declares a schema
-  const args = tool.inputSchema ? tool.inputSchema.parse(payload ?? {}) : (payload ?? {})
+  // Go injects chatId/workspaceId and may wrap the model's args inside a
+  // nested "args" object. Unwrap that before validation so the generated
+  // JSON Schema sees the flat tool contract shape.
+  let normalizedPayload = payload ?? {}
+  if (
+    normalizedPayload &&
+    typeof normalizedPayload === 'object' &&
+    !Array.isArray(normalizedPayload)
+  ) {
+    const raw = normalizedPayload as Record<string, unknown>
+    if (raw.args && typeof raw.args === 'object' && !raw.operation) {
+      const nested = raw.args as Record<string, unknown>
+      normalizedPayload = { ...nested, ...raw, args: undefined }
+    }
+  }
+
+  const args = tool.inputSchema
+    ? tool.inputSchema.parse(normalizedPayload)
+    : validateGeneratedToolPayload(toolName, 'parameters', normalizedPayload)
 
   assertServerToolNotAborted(context)
 
   // Execute
   const result = await tool.execute(args, context)
 
-  // Validate output if tool declares a schema
-  return tool.outputSchema ? tool.outputSchema.parse(result) : result
+  // Validate output if tool declares a schema; otherwise fall back to the
+  // generated JSON schema contract emitted from Go.
+  return tool.outputSchema
+    ? tool.outputSchema.parse(result)
+    : validateGeneratedToolPayload(toolName, 'resultSchema', result)
 }
diff --git a/apps/sim/lib/copilot/tools/server/table/user-table.ts b/apps/sim/lib/copilot/tools/server/table/user-table.ts
index e324c4c2b7b..b69c12c20ec 100644
--- a/apps/sim/lib/copilot/tools/server/table/user-table.ts
+++ b/apps/sim/lib/copilot/tools/server/table/user-table.ts
@@ -1,10 +1,10 @@
 import { createLogger } from '@sim/logger'
+import { UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
-import type { UserTableArgs, UserTableResult } from '@/lib/copilot/tools/shared/schemas'
 import { generateId } from '@/lib/core/utils/uuid'
 import { COLUMN_TYPES } from '@/lib/table/constants'
 import {
@@ -37,6 +37,17 @@ import {
 
 const logger = createLogger('UserTableServerTool')
 
+type UserTableArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type UserTableResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
 const MAX_BATCH_SIZE = 1000
 const SCHEMA_SAMPLE_SIZE = 100
 
@@ -240,9 +251,10 @@ async function batchInsertAll(
 }
 
 export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult> = {
-  name: 'user_table',
+  name: UserTable.id,
   async execute(params: UserTableArgs, context?: ServerToolContext): Promise<UserTableResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       logger.error('Unauthorized attempt to access user table - no authenticated user context')
@@ -726,7 +738,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           const coerced = coerceRows(rows, columns, columnMap)
           const inserted = await batchInsertAll(table.id, coerced, table, workspaceId, context)
 
-          reqLogger.info('Table created from file', {
+          logger.info('Table created from file', {
             tableId: table.id,
             fileName: file.name,
             columns: columns.length,
@@ -802,7 +814,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           const coerced = coerceRows(rows, matchedColumns, columnMap)
           const inserted = await batchInsertAll(table.id, coerced, table, workspaceId, context)
 
-          reqLogger.info('Rows imported from file', {
+          logger.info('Rows imported from file', {
             tableId: table.id,
             fileName: file.name,
             matchedColumns: mappedHeaders.length,
@@ -1000,7 +1012,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             ? error.cause.message
             : String(error.cause)
           : undefined
-      reqLogger.error('Table operation failed', {
+      logger.error('Table operation failed', {
         operation,
         error: errorMessage,
         cause,
diff --git a/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts b/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts
index 30f032e1114..56f1de2043f 100644
--- a/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts
+++ b/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts
@@ -3,6 +3,7 @@ import { credential } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, inArray } from 'drizzle-orm'
 import { z } from 'zod'
+import { SetEnvironmentVariables } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { upsertPersonalEnvVars, upsertWorkspaceEnvVars } from '@/lib/environment/utils'
 import { getWorkflowById } from '@/lib/workflows/utils'
@@ -35,7 +36,7 @@ function normalizeVariables(
 
 export const setEnvironmentVariablesServerTool: BaseServerTool<SetEnvironmentVariablesParams, any> =
   {
-    name: 'set_environment_variables',
+    name: SetEnvironmentVariables.id,
     async execute(
       params: SetEnvironmentVariablesParams,
       context?: { userId: string }
diff --git a/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts b/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts
index f58c40c4a9f..b639f3f1fe4 100644
--- a/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts
+++ b/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts
@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { GenerateVisualization } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -65,7 +66,8 @@ async function collectSandboxFiles(
   inputTables?: string[],
   messageId?: string
 ): Promise<SandboxFile[]> {
-  const reqLogger = logger.withMetadata({ messageId })
+  const withMessageId = (message: string) =>
+    messageId ? `${message} [messageId:${messageId}]` : message
   const sandboxFiles: SandboxFile[] = []
   let totalSize = 0
 
@@ -74,12 +76,12 @@ async function collectSandboxFiles(
     for (const fileRef of inputFiles) {
       const record = findWorkspaceFileRecord(allFiles, fileRef)
       if (!record) {
-        reqLogger.warn('Sandbox input file not found', { fileRef })
+        logger.warn('Sandbox input file not found', { fileRef })
         continue
       }
       const ext = record.name.split('.').pop()?.toLowerCase() ?? ''
       if (!TEXT_EXTENSIONS.has(ext)) {
-        reqLogger.warn('Skipping non-text sandbox input file', {
+        logger.warn('Skipping non-text sandbox input file', {
           fileId: record.id,
           fileName: record.name,
           ext,
@@ -87,7 +89,7 @@ async function collectSandboxFiles(
         continue
       }
       if (record.size > MAX_FILE_SIZE) {
-        reqLogger.warn('Sandbox input file exceeds size limit', {
+        logger.warn('Sandbox input file exceeds size limit', {
           fileId: record.id,
           fileName: record.name,
           size: record.size,
@@ -116,7 +118,7 @@ async function collectSandboxFiles(
     for (const tableId of inputTables) {
       const table = await getTableById(tableId)
       if (!table) {
-        reqLogger.warn('Sandbox input table not found', { tableId })
+        logger.warn('Sandbox input table not found', { tableId })
         continue
       }
       const { rows } = await queryRows(tableId, workspaceId, { limit: 10000 }, 'sandbox-input')
@@ -146,13 +148,14 @@ export const generateVisualizationServerTool: BaseServerTool<
   VisualizationArgs,
   VisualizationResult
 > = {
-  name: 'generate_visualization',
+  name: GenerateVisualization.id,
 
   async execute(
     params: VisualizationArgs,
     context?: ServerToolContext
   ): Promise<VisualizationResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       throw new Error('Authentication required')
@@ -237,7 +240,7 @@ export const generateVisualizationServerTool: BaseServerTool<
           imageBuffer,
           'image/png'
         )
-        reqLogger.info('Chart image overwritten', {
+        logger.info('Chart image overwritten', {
           fileId: updated.id,
           fileName: updated.name,
           size: imageBuffer.length,
@@ -261,7 +264,7 @@ export const generateVisualizationServerTool: BaseServerTool<
         'image/png'
       )
 
-      reqLogger.info('Chart image saved', {
+      logger.info('Chart image saved', {
         fileId: uploaded.id,
         fileName: uploaded.name,
         size: imageBuffer.length,
@@ -276,7 +279,7 @@ export const generateVisualizationServerTool: BaseServerTool<
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : 'Unknown error'
-      reqLogger.error('Visualization generation failed', { error: msg })
+      logger.error('Visualization generation failed', { error: msg })
       return { success: false, message: `Failed to generate visualization: ${msg}` }
     }
   },
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts
index 7be066d2989..fcfe183e62f 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { workflow as workflowTable } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
+import { EditWorkflow } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -66,7 +67,7 @@ async function getCurrentWorkflowStateFromDb(
 }
 
 export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown> = {
-  name: 'edit_workflow',
+  name: EditWorkflow.id,
   async execute(params: EditWorkflowParams, context?: ServerToolContext): Promise<unknown> {
     const logger = createLogger('EditWorkflowServerTool')
     const { operations, workflowId, currentUserWorkflow } = params
diff --git a/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts b/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts
index d80681f68d2..f561d7b6190 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { workflow, workflowExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq, type SQL } from 'drizzle-orm'
+import { GetExecutionSummary } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
 import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -41,7 +42,7 @@ export const getExecutionSummaryServerTool: BaseServerTool<
   GetExecutionSummaryArgs,
   ExecutionSummary[]
 > = {
-  name: 'get_execution_summary',
+  name: GetExecutionSummary.id,
   async execute(
     rawArgs: GetExecutionSummaryArgs,
     context?: ServerToolContext
diff --git a/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts b/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts
index 6d8a6fbc681..e64226ec497 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { workflowExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
+import { GetWorkflowLogs } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 
@@ -65,7 +66,7 @@ function extractBlockExecutionsFromTraceSpans(traceSpans: any[]): BlockExecution
 }
 
 export const getWorkflowLogsServerTool: BaseServerTool<GetWorkflowLogsArgs, any> = {
-  name: 'get_workflow_logs',
+  name: GetWorkflowLogs.id,
   async execute(rawArgs: GetWorkflowLogsArgs, context?: { userId: string }): Promise<any> {
     const {
       workflowId,
diff --git a/apps/sim/lib/copilot/tools/shared/schemas.ts b/apps/sim/lib/copilot/tools/shared/schemas.ts
deleted file mode 100644
index c59200e8466..00000000000
--- a/apps/sim/lib/copilot/tools/shared/schemas.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-import { z } from 'zod'
-
-// Generic envelope used by client to validate API responses
-export const ExecuteResponseSuccessSchema = z.object({
-  success: z.literal(true),
-  result: z.unknown(),
-})
-export type ExecuteResponseSuccess = z.infer<typeof ExecuteResponseSuccessSchema>
-
-// get_blocks_metadata
-export const GetBlocksMetadataInput = z.object({ blockIds: z.array(z.string()).min(1) })
-export const GetBlocksMetadataResult = z.object({ metadata: z.record(z.any()) })
-export type GetBlocksMetadataResultType = z.infer<typeof GetBlocksMetadataResult>
-
-// get_trigger_blocks
-export const GetTriggerBlocksInput = z.object({})
-export const GetTriggerBlocksResult = z.object({
-  triggerBlockIds: z.array(z.string()),
-})
-export type GetTriggerBlocksResultType = z.infer<typeof GetTriggerBlocksResult>
-
-// knowledge_base - shared schema used by client tool, server tool, and registry
-export const KnowledgeBaseArgsSchema = z.object({
-  operation: z.enum([
-    'create',
-    'get',
-    'query',
-    'update',
-    'delete',
-    'add_file',
-    'delete_document',
-    'update_document',
-    'list_tags',
-    'create_tag',
-    'update_tag',
-    'delete_tag',
-    'get_tag_usage',
-    'add_connector',
-    'update_connector',
-    'delete_connector',
-    'sync_connector',
-  ]),
-  args: z
-    .object({
-      /** Name of the knowledge base (required for create) */
-      name: z.string().optional(),
-      /** Description of the knowledge base (optional for create) */
-      description: z.string().optional(),
-      /** Workspace ID to associate with (required for create, optional for list) */
-      workspaceId: z.string().optional(),
-      /** Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage, add_connector) */
-      knowledgeBaseId: z.string().optional(),
-      /** Workspace file ID to add as a document (required for add_file). */
-      fileId: z.string().optional(),
-      /** Legacy workspace file reference for add_file. Prefer fileId. */
-      filePath: z.string().optional(),
-      /** Search query text (required for query) */
-      query: z.string().optional(),
-      /** Number of results to return (optional for query, defaults to 5) */
-      topK: z.number().min(1).max(50).optional(),
-      /** Chunking configuration (optional for create) */
-      chunkingConfig: z
-        .object({
-          maxSize: z.number().min(100).max(4000).default(1024),
-          minSize: z.number().min(1).max(2000).default(1),
-          overlap: z.number().min(0).max(500).default(200),
-        })
-        .optional(),
-      /** Tag definition ID (required for update_tag, delete_tag) */
-      tagDefinitionId: z.string().optional(),
-      /** Tag display name (required for create_tag, optional for update_tag) */
-      tagDisplayName: z.string().optional(),
-      /** Tag field type: text, number, date, boolean (optional for create_tag, defaults to text) */
-      tagFieldType: z.enum(['text', 'number', 'date', 'boolean']).optional(),
-      /** Connector type from registry, e.g. "confluence" (required for add_connector) */
-      connectorType: z.string().optional(),
-      /** OAuth credential ID from environment/credentials.json (required for OAuth connectors) */
-      credentialId: z.string().optional(),
-      /** API key for API key-based connectors (required for API key connectors) */
-      apiKey: z.string().optional(),
-      /** Connector-specific config matching the schema in knowledgebases/connectors/{type}.json */
-      sourceConfig: z.record(z.unknown()).optional(),
-      /** Sync interval: 60, 360, 1440, 10080, or 0 for manual only (optional for add_connector, defaults to 1440) */
-      syncIntervalMinutes: z.number().int().min(0).optional(),
-      /** Connector ID (required for update_connector, delete_connector, sync_connector) */
-      connectorId: z.string().optional(),
-      /** Connector status: "active" or "paused" (optional for update_connector) */
-      connectorStatus: z.enum(['active', 'paused']).optional(),
-      /** Tag definition IDs to disable (optional for add_connector) */
-      disabledTagIds: z.array(z.string()).optional(),
-      /** Document ID (required for delete_document, update_document) */
-      documentId: z.string().optional(),
-      /** Enable/disable a document (optional for update_document) */
-      enabled: z.boolean().optional(),
-      /** New filename for a document (optional for update_document) */
-      filename: z.string().optional(),
-    })
-    .optional(),
-})
-export type KnowledgeBaseArgs = z.infer<typeof KnowledgeBaseArgsSchema>
-
-export const KnowledgeBaseResultSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: z.any().optional(),
-})
-export type KnowledgeBaseResult = z.infer<typeof KnowledgeBaseResultSchema>
-
-// user_table - shared schema used by server tool and registry
-export const UserTableArgsSchema = z.object({
-  operation: z.enum([
-    'create',
-    'create_from_file',
-    'import_file',
-    'get',
-    'get_schema',
-    'delete',
-    'insert_row',
-    'batch_insert_rows',
-    'get_row',
-    'query_rows',
-    'update_row',
-    'delete_row',
-    'update_rows_by_filter',
-    'delete_rows_by_filter',
-    'batch_update_rows',
-    'batch_delete_rows',
-    'add_column',
-    'rename_column',
-    'delete_column',
-    'update_column',
-    'rename',
-  ]),
-  args: z
-    .object({
-      name: z.string().optional(),
-      description: z.string().optional(),
-      schema: z.any().optional(),
-      tableId: z.string().optional(),
-      rowId: z.string().optional(),
-      data: z.record(z.any()).optional(),
-      rows: z.array(z.record(z.any())).optional(),
-      updates: z.array(z.object({ rowId: z.string(), data: z.record(z.any()) })).optional(),
-      rowIds: z.array(z.string()).optional(),
-      values: z.record(z.any()).optional(),
-      filter: z.any().optional(),
-      sort: z.record(z.enum(['asc', 'desc'])).optional(),
-      limit: z.number().optional(),
-      offset: z.number().optional(),
-      fileId: z.string().optional(),
-      filePath: z.string().optional(),
-      column: z
-        .object({
-          name: z.string(),
-          type: z.string(),
-          unique: z.boolean().optional(),
-          position: z.number().optional(),
-        })
-        .optional(),
-      columnName: z.string().optional(),
-      columnNames: z.array(z.string()).optional(),
-      newName: z.string().optional(),
-      newType: z.string().optional(),
-      unique: z.boolean().optional(),
-    })
-    .optional(),
-})
-export type UserTableArgs = z.infer<typeof UserTableArgsSchema>
-
-export const UserTableResultSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: z.any().optional(),
-})
-export type UserTableResult = z.infer<typeof UserTableResultSchema>
-
-// workspace_file - shared schema used by server tool and Go catalog
-export const WorkspaceFileArgsSchema = z.object({
-  operation: z.enum(['write', 'update', 'delete', 'rename', 'patch']),
-  args: z
-    .object({
-      fileId: z.string().optional(),
-      fileName: z.string().optional(),
-      content: z.string().optional(),
-      contentType: z.string().optional(),
-      workspaceId: z.string().optional(),
-      newName: z.string().optional(),
-      edits: z
-        .array(z.object({ search: z.string(), replace: z.string() }))
-        .describe(
-          'List of search/replace pairs applied sequentially — each edit operates on the result of the previous one. Search strings must be unique within the file.'
-        )
-        .optional(),
-    })
-    .optional(),
-})
-export type WorkspaceFileArgs = z.infer<typeof WorkspaceFileArgsSchema>
-
-export const WorkspaceFileResultSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: z.any().optional(),
-})
-export type WorkspaceFileResult = z.infer<typeof WorkspaceFileResultSchema>
-
-export const GetBlockOutputsInput = z.object({
-  blockIds: z.array(z.string()).optional(),
-})
-export const GetBlockOutputsResult = z.object({
-  blocks: z.array(
-    z.object({
-      blockId: z.string(),
-      blockName: z.string(),
-      blockType: z.string(),
-      triggerMode: z.boolean().optional(),
-      outputs: z.array(z.string()),
-      insideSubflowOutputs: z.array(z.string()).optional(),
-      outsideSubflowOutputs: z.array(z.string()).optional(),
-    })
-  ),
-  variables: z
-    .array(
-      z.object({
-        id: z.string(),
-        name: z.string(),
-        type: z.string(),
-        tag: z.string(),
-      })
-    )
-    .optional(),
-})
-export type GetBlockOutputsInputType = z.infer<typeof GetBlockOutputsInput>
-export type GetBlockOutputsResultType = z.infer<typeof GetBlockOutputsResult>
-
-export const GetBlockUpstreamReferencesInput = z.object({
-  blockIds: z.array(z.string()).min(1),
-})
-export const GetBlockUpstreamReferencesResult = z.object({
-  results: z.array(
-    z.object({
-      blockId: z.string(),
-      blockName: z.string(),
-      insideSubflows: z
-        .array(
-          z.object({
-            blockId: z.string(),
-            blockName: z.string(),
-            blockType: z.string(),
-          })
-        )
-        .optional(),
-      accessibleBlocks: z.array(
-        z.object({
-          blockId: z.string(),
-          blockName: z.string(),
-          blockType: z.string(),
-          triggerMode: z.boolean().optional(),
-          outputs: z.array(z.string()),
-          accessContext: z.enum(['inside', 'outside']).optional(),
-        })
-      ),
-      variables: z.array(
-        z.object({
-          id: z.string(),
-          name: z.string(),
-          type: z.string(),
-          tag: z.string(),
-        })
-      ),
-    })
-  ),
-})
-export type GetBlockUpstreamReferencesInputType = z.infer<typeof GetBlockUpstreamReferencesInput>
-export type GetBlockUpstreamReferencesResultType = z.infer<typeof GetBlockUpstreamReferencesResult>
diff --git a/apps/sim/lib/copilot/workflow-tools.ts b/apps/sim/lib/copilot/tools/workflow-tools.ts
similarity index 87%
rename from apps/sim/lib/copilot/workflow-tools.ts
rename to apps/sim/lib/copilot/tools/workflow-tools.ts
index ecfba90cebf..fc750614dfb 100644
--- a/apps/sim/lib/copilot/workflow-tools.ts
+++ b/apps/sim/lib/copilot/tools/workflow-tools.ts
@@ -1,4 +1,4 @@
-export const WORKFLOW_TOOL_NAMES = [
+const WORKFLOW_TOOL_NAMES = [
   'run_workflow',
   'run_workflow_until_block',
   'run_block',
diff --git a/apps/sim/lib/copilot/types.ts b/apps/sim/lib/copilot/types.ts
deleted file mode 100644
index 031e835318a..00000000000
--- a/apps/sim/lib/copilot/types.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { CopilotToolCall, ToolState } from '@/stores/panel'
-
-export type NotificationStatus =
-  | 'pending'
-  | 'success'
-  | 'error'
-  | 'accepted'
-  | 'rejected'
-  | 'background'
-  | 'cancelled'
-
-export type { CopilotToolCall, ToolState }
-
-export interface AvailableModel {
-  id: string
-  friendlyName: string
-  provider: string
-}
diff --git a/apps/sim/lib/copilot/utils.ts b/apps/sim/lib/copilot/utils.ts
deleted file mode 100644
index cb6b25979d8..00000000000
--- a/apps/sim/lib/copilot/utils.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import type { NextRequest } from 'next/server'
-import { env } from '@/lib/core/config/env'
-import { safeCompare } from '@/lib/core/security/encryption'
-
-export function checkInternalApiKey(req: NextRequest) {
-  const apiKey = req.headers.get('x-api-key')
-  const expectedApiKey = env.INTERNAL_API_SECRET
-
-  if (!expectedApiKey) {
-    return { success: false, error: 'Internal API key not configured' }
-  }
-
-  if (!apiKey) {
-    return { success: false, error: 'API key required' }
-  }
-
-  if (!safeCompare(apiKey, expectedApiKey)) {
-    return { success: false, error: 'Invalid API key' }
-  }
-
-  return { success: true }
-}
diff --git a/apps/sim/lib/copilot/vfs/file-reader.ts b/apps/sim/lib/copilot/vfs/file-reader.ts
index d3fd77aaf3a..00f2e2dc55e 100644
--- a/apps/sim/lib/copilot/vfs/file-reader.ts
+++ b/apps/sim/lib/copilot/vfs/file-reader.ts
@@ -31,6 +31,16 @@ function getExtension(filename: string): string {
   return dot >= 0 ? filename.slice(dot + 1).toLowerCase() : ''
 }
 
+function detectImageMime(buf: Buffer, claimed: string): string {
+  if (buf.length < 12) return claimed
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) return 'image/jpeg'
+  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return 'image/png'
+  if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46) return 'image/gif'
+  if (buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50)
+    return 'image/webp'
+  return claimed
+}
+
 export interface FileReadResult {
   content: string
   totalLines: number
@@ -59,14 +69,15 @@ export async function readFileRecord(record: WorkspaceFileRecord): Promise<FileR
         }
       }
       const buffer = await downloadWorkspaceFile(record)
+      const mime = detectImageMime(buffer, record.type)
       return {
-        content: `Image: ${record.name} (${(record.size / 1024).toFixed(1)}KB, ${record.type})`,
+        content: `Image: ${record.name} (${(record.size / 1024).toFixed(1)}KB, ${mime})`,
         totalLines: 1,
         attachment: {
           type: 'image',
           source: {
             type: 'base64',
-            media_type: record.type,
+            media_type: mime,
             data: buffer.toString('base64'),
           },
         },
diff --git a/apps/sim/lib/copilot/vfs/serializers.ts b/apps/sim/lib/copilot/vfs/serializers.ts
index 524e8567e01..38644bc65e5 100644
--- a/apps/sim/lib/copilot/vfs/serializers.ts
+++ b/apps/sim/lib/copilot/vfs/serializers.ts
@@ -1,4 +1,4 @@
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { getCopilotToolDescription } from '@/lib/copilot/tools/descriptions'
 import { isHosted } from '@/lib/core/config/feature-flags'
 import { isSubBlockHidden } from '@/lib/workflows/subblocks/visibility'
 import type { BlockConfig, SubBlockConfig } from '@/blocks/types'
@@ -12,6 +12,7 @@ export function serializeWorkflowMeta(wf: {
   id: string
   name: string
   description?: string | null
+  folderId?: string | null
   isDeployed: boolean
   deployedAt?: Date | null
   runCount: number
@@ -24,6 +25,7 @@ export function serializeWorkflowMeta(wf: {
       id: wf.id,
       name: wf.name,
       description: wf.description || undefined,
+      folderId: wf.folderId || undefined,
       isDeployed: wf.isDeployed,
       deployedAt: wf.deployedAt?.toISOString(),
       runCount: wf.runCount,
diff --git a/apps/sim/lib/copilot/vfs/workspace-vfs.ts b/apps/sim/lib/copilot/vfs/workspace-vfs.ts
index e43e5b03ec6..122cd8488f3 100644
--- a/apps/sim/lib/copilot/vfs/workspace-vfs.ts
+++ b/apps/sim/lib/copilot/vfs/workspace-vfs.ts
@@ -17,6 +17,7 @@ import {
 import { createLogger } from '@sim/logger'
 import { and, desc, eq, isNull, ne } from 'drizzle-orm'
 import { listApiKeys } from '@/lib/api-key/service'
+import { buildWorkspaceMd, type WorkspaceMdData } from '@/lib/copilot/chat/workspace-context'
 import { type FileReadResult, readFileRecord } from '@/lib/copilot/vfs/file-reader'
 import { normalizeVfsSegment } from '@/lib/copilot/vfs/normalize-segment'
 import type { DirEntry, GrepMatch, GrepOptions, ReadResult } from '@/lib/copilot/vfs/operations'
@@ -49,7 +50,6 @@ import {
   serializeVersions,
   serializeWorkflowMeta,
 } from '@/lib/copilot/vfs/serializers'
-import { buildWorkspaceMd, type WorkspaceMdData } from '@/lib/copilot/workspace-context'
 import {
   getAccessibleEnvCredentials,
   getAccessibleOAuthCredentials,
@@ -66,7 +66,7 @@ import { listCustomTools } from '@/lib/workflows/custom-tools/operations'
 import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import { listSkills } from '@/lib/workflows/skills/operations'
-import { listWorkflows } from '@/lib/workflows/utils'
+import { listFolders, listWorkflows } from '@/lib/workflows/utils'
 import {
   assertActiveWorkspaceAccess,
   getUsersWithPermissions,
@@ -118,6 +118,10 @@ function getStaticComponentFiles(): Map<string, string> {
 
   const latestTools = getLatestVersionTools(toolRegistry)
   let integrationCount = 0
+
+  const oauthServices = new Map<string, { provider: string; operations: string[] }>()
+  const apiKeyServices = new Map<string, { params: string[]; operations: string[] }>()
+
   for (const [toolId, tool] of Object.entries(latestTools)) {
     const baseName = stripVersionSuffix(toolId)
     const service = toolToService.get(toolId) ?? toolToService.get(baseName)
@@ -132,8 +136,39 @@ function getStaticComponentFiles(): Map<string, string> {
     const path = `components/integrations/${service}/${operation}.json`
     files.set(path, serializeIntegrationSchema(tool))
     integrationCount++
+
+    if (tool.oauth?.required) {
+      const existing = oauthServices.get(service)
+      if (existing) {
+        existing.operations.push(operation)
+      } else {
+        oauthServices.set(service, { provider: tool.oauth.provider, operations: [operation] })
+      }
+    } else if (tool.hosting?.apiKeyParam) {
+      const existing = apiKeyServices.get(service)
+      if (existing) {
+        if (!existing.params.includes(tool.hosting.apiKeyParam)) {
+          existing.params.push(tool.hosting.apiKeyParam)
+        }
+        existing.operations.push(operation)
+      } else {
+        apiKeyServices.set(service, {
+          params: [tool.hosting.apiKeyParam],
+          operations: [operation],
+        })
+      }
+    }
   }
 
+  files.set(
+    'environment/oauth-integrations.json',
+    JSON.stringify(Object.fromEntries(oauthServices), null, 2)
+  )
+  files.set(
+    'environment/api-key-integrations.json',
+    JSON.stringify(Object.fromEntries(apiKeyServices), null, 2)
+  )
+
   files.set(
     'components/blocks/loop.json',
     JSON.stringify(
@@ -262,10 +297,11 @@ function getStaticComponentFiles(): Map<string, string> {
  *
  * Structure:
  *   WORKSPACE.md                         — workspace identity, members, inventory (auto-generated)
- *   workflows/{name}/meta.json
+ *   workflows/{name}/meta.json            (root-level workflows)
  *   workflows/{name}/state.json          (sanitized blocks with embedded connections)
  *   workflows/{name}/executions.json
  *   workflows/{name}/deployment.json
+ *   workflows/{folder}/{name}/...        (workflows inside folders, nested folders supported)
  *   knowledgebases/{name}/meta.json
  *   knowledgebases/{name}/documents.json
  *   knowledgebases/{name}/connectors.json
@@ -415,20 +451,70 @@ export class WorkspaceVFS {
     }
   }
 
+  /**
+   * Build a map from folderId to its full VFS path segment (e.g. "My Folder/Sub Folder").
+   * Handles nested folders via parentId traversal.
+   */
+  private buildFolderPaths(
+    folders: Array<{ folderId: string; folderName: string; parentId: string | null }>
+  ): Map<string, string> {
+    const folderMap = new Map<string, { name: string; parentId: string | null }>()
+    for (const f of folders) {
+      folderMap.set(f.folderId, { name: f.folderName, parentId: f.parentId })
+    }
+
+    const cache = new Map<string, string>()
+    const resolve = (id: string): string => {
+      if (cache.has(id)) return cache.get(id)!
+      const folder = folderMap.get(id)
+      if (!folder) return ''
+      const parentPath = folder.parentId ? resolve(folder.parentId) : ''
+      const path = parentPath
+        ? `${parentPath}/${sanitizeName(folder.name)}`
+        : sanitizeName(folder.name)
+      cache.set(id, path)
+      return path
+    }
+
+    for (const id of folderMap.keys()) {
+      resolve(id)
+    }
+    return cache
+  }
+
   /**
    * Materialize all workflows using the shared listWorkflows function.
+   * Workflows are nested under their folder paths in the VFS:
+   *   workflows/{folder}/{name}/  (if in a folder)
+   *   workflows/{name}/           (if at workspace root)
    * Returns a summary for WORKSPACE.md generation.
    */
   private async materializeWorkflows(
     workspaceId: string,
     _userId: string
   ): Promise<WorkspaceMdData['workflows']> {
-    const workflowRows = await listWorkflows(workspaceId)
+    const [workflowRows, folderRows] = await Promise.all([
+      listWorkflows(workspaceId),
+      listFolders(workspaceId),
+    ])
+
+    const folderPaths = this.buildFolderPaths(folderRows)
+
+    // Register all folders in the VFS so empty folders are discoverable.
+    for (const { folderId } of folderRows) {
+      const folderPath = folderPaths.get(folderId)
+      if (folderPath) {
+        this.files.set(`workflows/${folderPath}/.folder`, '')
+      }
+    }
 
     await Promise.all(
       workflowRows.map(async (wf) => {
         const safeName = sanitizeName(wf.name)
-        const prefix = `workflows/${safeName}/`
+        const folderPath = wf.folderId ? folderPaths.get(wf.folderId) : null
+        const prefix = folderPath
+          ? `workflows/${folderPath}/${safeName}/`
+          : `workflows/${safeName}/`
 
         this.files.set(`${prefix}meta.json`, serializeWorkflowMeta(wf))
 
@@ -506,6 +592,7 @@ export class WorkspaceVFS {
       description: wf.description,
       isDeployed: wf.isDeployed,
       lastRunAt: wf.lastRunAt,
+      folderPath: wf.folderId ? (folderPaths.get(wf.folderId) ?? null) : null,
     }))
   }
 
diff --git a/apps/sim/lib/copilot/workflow-read-hashes.ts b/apps/sim/lib/copilot/workflow-read-hashes.ts
deleted file mode 100644
index adca180dc84..00000000000
--- a/apps/sim/lib/copilot/workflow-read-hashes.ts
+++ /dev/null
@@ -1,115 +0,0 @@
-import crypto from 'crypto'
-import { db } from '@sim/db'
-import { copilotWorkflowReadHashes } from '@sim/db/schema'
-import { and, eq } from 'drizzle-orm'
-import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
-
-type WorkflowStateLike = {
-  blocks?: Record<string, unknown>
-  edges?: unknown[]
-  loops?: Record<string, unknown>
-  parallels?: Record<string, unknown>
-}
-
-export function canonicalizeForHash(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map(canonicalizeForHash)
-  }
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value as Record<string, unknown>)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([key, nested]) => [key, canonicalizeForHash(nested)])
-    )
-  }
-  return value
-}
-
-export function hashCanonicalJson(value: unknown): string {
-  const canonical = JSON.stringify(canonicalizeForHash(value))
-  return crypto.createHash('sha256').update(canonical).digest('hex')
-}
-
-export function computeWorkflowReadHashFromSanitizedState(sanitizedState: unknown): string {
-  return hashCanonicalJson(sanitizedState)
-}
-
-export function computeWorkflowReadHashFromWorkflowState(state: WorkflowStateLike): {
-  sanitizedState: ReturnType<typeof sanitizeForCopilot>
-  hash: string
-} {
-  const sanitizedState = sanitizeForCopilot({
-    blocks: state.blocks || {},
-    edges: state.edges || [],
-    loops: state.loops || {},
-    parallels: state.parallels || {},
-  } as Parameters<typeof sanitizeForCopilot>[0])
-
-  return {
-    sanitizedState,
-    hash: computeWorkflowReadHashFromSanitizedState(sanitizedState),
-  }
-}
-
-export async function getWorkflowReadHash(
-  chatId: string,
-  workflowId: string
-): Promise<string | null> {
-  const [row] = await db
-    .select({ hash: copilotWorkflowReadHashes.hash })
-    .from(copilotWorkflowReadHashes)
-    .where(
-      and(
-        eq(copilotWorkflowReadHashes.chatId, chatId),
-        eq(copilotWorkflowReadHashes.workflowId, workflowId)
-      )
-    )
-    .limit(1)
-
-  return row?.hash ?? null
-}
-
-export async function upsertWorkflowReadHash(
-  chatId: string,
-  workflowId: string,
-  hash: string
-): Promise<void> {
-  await db
-    .insert(copilotWorkflowReadHashes)
-    .values({
-      chatId,
-      workflowId,
-      hash,
-      updatedAt: new Date(),
-    })
-    .onConflictDoUpdate({
-      target: [copilotWorkflowReadHashes.chatId, copilotWorkflowReadHashes.workflowId],
-      set: {
-        hash,
-        updatedAt: new Date(),
-      },
-    })
-}
-
-export async function upsertWorkflowReadHashForWorkflowState(
-  chatId: string,
-  workflowId: string,
-  state: WorkflowStateLike
-): Promise<{
-  sanitizedState: ReturnType<typeof sanitizeForCopilot>
-  hash: string
-}> {
-  const computed = computeWorkflowReadHashFromWorkflowState(state)
-  await upsertWorkflowReadHash(chatId, workflowId, computed.hash)
-  return computed
-}
-
-export async function upsertWorkflowReadHashForSanitizedState(
-  chatId: string,
-  workflowId: string,
-  sanitizedState: unknown
-): Promise<string> {
-  const hash = computeWorkflowReadHashFromSanitizedState(sanitizedState)
-  await upsertWorkflowReadHash(chatId, workflowId, hash)
-  return hash
-}
diff --git a/apps/sim/lib/core/config/env.ts b/apps/sim/lib/core/config/env.ts
index f4c751b7b72..3d180e5e624 100644
--- a/apps/sim/lib/core/config/env.ts
+++ b/apps/sim/lib/core/config/env.ts
@@ -38,9 +38,6 @@ export const env = createEnv({
     AGENT_INDEXER_API_KEY:                 z.string().min(1).optional(),           // API key for agent indexer authentication
     COPILOT_STREAM_TTL_SECONDS:            z.number().optional(),                  // Redis TTL for copilot SSE buffer
     COPILOT_STREAM_EVENT_LIMIT:            z.number().optional(),                  // Max events retained per stream
-    COPILOT_STREAM_RESERVE_BATCH:          z.number().optional(),                  // Event ID reservation batch size
-    COPILOT_STREAM_FLUSH_INTERVAL_MS:      z.number().optional(),                  // Buffer flush interval in ms
-    COPILOT_STREAM_FLUSH_MAX_BATCH:        z.number().optional(),                  // Max events per flush batch
 
     // Database & Storage
     REDIS_URL:                             z.string().url().optional(),            // Redis connection string for caching/sessions
@@ -327,6 +324,7 @@ export const env = createEnv({
     // E2B Remote Code Execution
     E2B_ENABLED:                           z.string().optional(),                  // Enable E2B remote code execution
     E2B_API_KEY:                           z.string().optional(),                  // E2B API key for sandbox creation
+    MOTHERSHIP_E2B_TEMPLATE_ID:             z.string().optional(),                  // Custom E2B template with pre-installed CLI tools for shell execution
 
     // Credential Sets (Email Polling) - for self-hosted deployments
     CREDENTIAL_SETS_ENABLED:               z.boolean().optional(),                 // Enable credential sets on self-hosted (bypasses plan requirements)
diff --git a/apps/sim/lib/execution/doc-vm.ts b/apps/sim/lib/execution/doc-vm.ts
new file mode 100644
index 00000000000..2620f2e47cf
--- /dev/null
+++ b/apps/sim/lib/execution/doc-vm.ts
@@ -0,0 +1,211 @@
+/**
+ * Sandboxed document generation via subprocess.
+ *
+ * Supports pptx (pptxgenjs), docx (docx), and pdf (pdf-lib).
+ * User code runs in a separate Node.js child process. File access is brokered
+ * via IPC -- the subprocess never touches the database directly.
+ */
+
+import { type ChildProcess, spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createLogger } from '@sim/logger'
+import {
+  downloadWorkspaceFile,
+  getWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('DocVMExecution')
+
+export type DocumentFormat = 'pptx' | 'docx' | 'pdf'
+
+const WORKER_STARTUP_TIMEOUT_MS = 10_000
+const GENERATION_TIMEOUT_MS = 60_000
+const MAX_STDERR = 4096
+
+type WorkerMessage =
+  | { type: 'ready' }
+  | { type: 'result'; data: string }
+  | { type: 'error'; message: string }
+  | { type: 'getFile'; fileReqId: number; fileId: string }
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+let cachedWorkerPath: string | undefined
+
+function getWorkerPath(): string {
+  if (cachedWorkerPath) return cachedWorkerPath
+  const candidates = [
+    path.join(currentDir, '..', '..', 'dist', 'doc-worker.cjs'),
+    path.join(currentDir, 'doc-worker.cjs'),
+    path.join(process.cwd(), 'apps', 'sim', 'dist', 'doc-worker.cjs'),
+    path.join(process.cwd(), 'apps', 'sim', 'lib', 'execution', 'doc-worker.cjs'),
+    path.join(process.cwd(), 'dist', 'doc-worker.cjs'),
+    path.join(process.cwd(), 'lib', 'execution', 'doc-worker.cjs'),
+  ]
+  const found = candidates.find((p) => fs.existsSync(p))
+  if (!found) throw new Error(`doc-worker.cjs not found at any of: ${candidates.join(', ')}`)
+  cachedWorkerPath = found
+  return found
+}
+
+export async function generateDocumentFromCode(
+  format: DocumentFormat,
+  code: string,
+  workspaceId: string,
+  signal?: AbortSignal
+): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    let proc: ChildProcess | null = null
+    let settled = false
+    let startupTimer: ReturnType<typeof setTimeout> | null = null
+    let generationTimer: ReturnType<typeof setTimeout> | null = null
+
+    function done(err: Error): void
+    function done(err: undefined, result: Buffer): void
+    function done(err: Error | undefined, result?: Buffer): void {
+      if (settled) return
+      settled = true
+      if (startupTimer) clearTimeout(startupTimer)
+      if (generationTimer) clearTimeout(generationTimer)
+      try {
+        proc?.removeAllListeners()
+        proc?.kill()
+      } catch {
+        // Ignore -- process may have already exited
+      }
+      if (err) reject(err)
+      else resolve(result as Buffer)
+    }
+
+    if (signal?.aborted) {
+      reject(new Error(`${format.toUpperCase()} generation cancelled`))
+      return
+    }
+
+    signal?.addEventListener(
+      'abort',
+      () => done(new Error(`${format.toUpperCase()} generation cancelled`)),
+      { once: true }
+    )
+
+    try {
+      proc = spawn('node', [getWorkerPath()], {
+        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        serialization: 'json',
+        env: { PATH: process.env.PATH ?? '' } as unknown as NodeJS.ProcessEnv,
+      })
+    } catch (err) {
+      done(err instanceof Error ? err : new Error(String(err)))
+      return
+    }
+
+    let stderrData = ''
+    proc.stderr?.on('data', (chunk: Buffer) => {
+      if (stderrData.length < MAX_STDERR) {
+        stderrData += chunk.toString()
+        if (stderrData.length > MAX_STDERR) stderrData = stderrData.slice(0, MAX_STDERR)
+      }
+    })
+
+    startupTimer = setTimeout(() => {
+      logger.error(`${format} worker failed to start within timeout`)
+      done(new Error(`${format.toUpperCase()} worker failed to start`))
+    }, WORKER_STARTUP_TIMEOUT_MS)
+
+    proc.on('exit', (code) => {
+      if (!settled) {
+        logger.error(`${format} worker exited unexpectedly`, {
+          code,
+          stderr: stderrData.slice(0, 500),
+        })
+        done(new Error(`${format.toUpperCase()} worker exited unexpectedly (code ${code})`))
+      }
+    })
+
+    proc.on('error', (err) => {
+      logger.error(`${format} worker process error`, { error: err.message })
+      done(err)
+    })
+
+    proc.on('message', (rawMsg: unknown) => {
+      const msg = rawMsg as WorkerMessage
+
+      if (msg.type === 'ready') {
+        if (startupTimer) {
+          clearTimeout(startupTimer)
+          startupTimer = null
+        }
+        generationTimer = setTimeout(() => {
+          logger.error(`${format} generation timed out`)
+          done(new Error(`${format.toUpperCase()} generation timed out`))
+        }, GENERATION_TIMEOUT_MS)
+        proc!.send({ type: 'generate', format, code })
+        return
+      }
+
+      if (msg.type === 'result') {
+        done(undefined, Buffer.from(msg.data, 'base64'))
+        return
+      }
+
+      if (msg.type === 'error') {
+        done(new Error(msg.message))
+        return
+      }
+
+      if (msg.type === 'getFile') {
+        handleFileRequest(proc!, workspaceId, msg).catch((err) => {
+          logger.error(`Failed to handle file request from ${format} worker`, {
+            fileId: msg.fileId,
+            error: err instanceof Error ? err.message : String(err),
+          })
+          if (proc && !settled) {
+            try {
+              proc.send({
+                type: 'fileResult',
+                fileReqId: msg.fileReqId,
+                error: err instanceof Error ? err.message : 'File fetch failed',
+              })
+            } catch {
+              // Ignore -- process may have died
+            }
+          }
+        })
+      }
+    })
+  })
+}
+
+async function handleFileRequest(
+  proc: ChildProcess,
+  workspaceId: string,
+  msg: Extract<WorkerMessage, { type: 'getFile' }>
+): Promise<void> {
+  const record = await getWorkspaceFile(workspaceId, msg.fileId)
+  if (!record) {
+    proc.send({
+      type: 'fileResult',
+      fileReqId: msg.fileReqId,
+      error: `File not found: ${msg.fileId}`,
+    })
+    return
+  }
+
+  const buffer = await downloadWorkspaceFile(record)
+  const mime = record.type || 'image/png'
+  proc.send({
+    type: 'fileResult',
+    fileReqId: msg.fileReqId,
+    data: `data:${mime};base64,${buffer.toString('base64')}`,
+  })
+}
+
+export const generatePptxFromCode = (code: string, workspaceId: string, signal?: AbortSignal) =>
+  generateDocumentFromCode('pptx', code, workspaceId, signal)
+
+export const generateDocxFromCode = (code: string, workspaceId: string, signal?: AbortSignal) =>
+  generateDocumentFromCode('docx', code, workspaceId, signal)
+
+export const generatePdfFromCode = (code: string, workspaceId: string, signal?: AbortSignal) =>
+  generateDocumentFromCode('pdf', code, workspaceId, signal)
diff --git a/apps/sim/lib/execution/doc-worker.cjs b/apps/sim/lib/execution/doc-worker.cjs
new file mode 100644
index 00000000000..6290653917f
--- /dev/null
+++ b/apps/sim/lib/execution/doc-worker.cjs
@@ -0,0 +1,162 @@
+/**
+ * Generic document generation worker.
+ * Runs in a separate Node.js process, communicates with parent via IPC.
+ * Supports pptx (pptxgenjs), docx (docx), and pdf (pdf-lib).
+ */
+
+'use strict'
+
+const vm = require('node:vm')
+
+const EXECUTION_TIMEOUT_MS = 30_000
+const FILE_REQUEST_TIMEOUT_MS = 30_000
+
+const FORMATS = {
+  pptx: {
+    setup() {
+      const PptxGenJS = require('pptxgenjs')
+      const pptx = new PptxGenJS()
+      return { globals: { pptx }, pptx }
+    },
+    async serialize(ctx) {
+      const output = await ctx.pptx.write({ outputType: 'nodebuffer' })
+      return Buffer.from(output)
+    },
+  },
+  docx: {
+    setup() {
+      const docx = require('docx')
+      const _sections = []
+      return { globals: { docx, addSection: (s) => _sections.push(s) }, _sections, docx }
+    },
+    async serialize(ctx) {
+      if (ctx.globals.doc) {
+        return ctx.docx.Packer.toBuffer(ctx.globals.doc)
+      }
+      if (ctx._sections.length > 0) {
+        const doc = new ctx.docx.Document({ sections: ctx._sections })
+        return ctx.docx.Packer.toBuffer(doc)
+      }
+      throw new Error(
+        'No document created. Use addSection({ children: [...] }) for chunked writes, or set doc = new docx.Document({...}) for a single write.'
+      )
+    },
+  },
+  pdf: {
+    async setup() {
+      const PDFLib = require('pdf-lib')
+      const pdf = await PDFLib.PDFDocument.create()
+
+      async function embedImage(dataUri) {
+        const base64 = dataUri.split(',')[1]
+        const bytes = Buffer.from(base64, 'base64')
+        const mime = dataUri.split(';')[0].split(':')[1] || ''
+        if (mime.includes('png')) return pdf.embedPng(bytes)
+        return pdf.embedJpg(bytes)
+      }
+
+      return { globals: { PDFLib, pdf, embedImage }, pdf }
+    },
+    async serialize(ctx) {
+      const pdf = ctx.globals.pdf
+      if (!pdf)
+        throw new Error(
+          'No PDF document. Use the injected pdf object or load one with PDFLib.PDFDocument.load().'
+        )
+      const bytes = await pdf.save()
+      return Buffer.from(bytes)
+    },
+  },
+}
+
+const pendingFileRequests = new Map()
+let fileRequestCounter = 0
+
+function sendToParent(msg) {
+  if (process.send && process.connected) {
+    process.send(msg)
+    return true
+  }
+  return false
+}
+
+process.on('message', async (msg) => {
+  if (msg.type === 'generate') {
+    await handleGenerate(msg)
+  } else if (msg.type === 'fileResult') {
+    handleFileResult(msg)
+  }
+})
+
+async function handleGenerate(msg) {
+  const { code, format } = msg
+
+  try {
+    const formatConfig = FORMATS[format]
+    if (!formatConfig) throw new Error(`Unknown document format: ${format}`)
+
+    const ctx = await formatConfig.setup()
+
+    const getFileBase64 = (fileId) =>
+      new Promise((resolve, reject) => {
+        if (typeof fileId !== 'string' || fileId.length === 0) {
+          reject(new Error('fileId must be a non-empty string'))
+          return
+        }
+
+        const fileReqId = ++fileRequestCounter
+        const timeout = setTimeout(() => {
+          if (pendingFileRequests.has(fileReqId)) {
+            pendingFileRequests.delete(fileReqId)
+            reject(new Error(`File request timed out for fileId: ${fileId}`))
+          }
+        }, FILE_REQUEST_TIMEOUT_MS)
+
+        pendingFileRequests.set(fileReqId, { resolve, reject, timeout })
+
+        if (!sendToParent({ type: 'getFile', fileReqId, fileId })) {
+          clearTimeout(timeout)
+          pendingFileRequests.delete(fileReqId)
+          reject(new Error('Parent process disconnected'))
+        }
+      })
+
+    const sandbox = Object.create(null)
+    Object.assign(sandbox, ctx.globals)
+    sandbox.getFileBase64 = getFileBase64
+
+    vm.createContext(sandbox)
+
+    const promise = vm.runInContext(`(async () => { ${code} })()`, sandbox, {
+      timeout: EXECUTION_TIMEOUT_MS,
+      filename: `${format}-code.js`,
+    })
+    await promise
+
+    ctx.globals = sandbox
+
+    const output = await formatConfig.serialize(ctx)
+    const base64 = Buffer.from(output).toString('base64')
+    sendToParent({ type: 'result', data: base64 })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    sendToParent({ type: 'error', message })
+  }
+}
+
+function handleFileResult(msg) {
+  const { fileReqId, data, error } = msg
+  const pending = pendingFileRequests.get(fileReqId)
+  if (!pending) return
+
+  clearTimeout(pending.timeout)
+  pendingFileRequests.delete(fileReqId)
+
+  if (error) {
+    pending.reject(new Error(error))
+  } else {
+    pending.resolve(data)
+  }
+}
+
+sendToParent({ type: 'ready' })
diff --git a/apps/sim/lib/execution/e2b.ts b/apps/sim/lib/execution/e2b.ts
index f312fc21e4a..1338b35d28f 100644
--- a/apps/sim/lib/execution/e2b.ts
+++ b/apps/sim/lib/execution/e2b.ts
@@ -6,6 +6,7 @@ import { CodeLanguage } from '@/lib/execution/languages'
 export interface SandboxFile {
   path: string
   content: string
+  encoding?: 'base64'
 }
 
 export interface E2BExecutionRequest {
@@ -13,6 +14,15 @@ export interface E2BExecutionRequest {
   language: CodeLanguage
   timeoutMs: number
   sandboxFiles?: SandboxFile[]
+  outputSandboxPath?: string
+}
+
+export interface E2BShellExecutionRequest {
+  code: string
+  envs: Record<string, string>
+  timeoutMs: number
+  sandboxFiles?: SandboxFile[]
+  outputSandboxPath?: string
 }
 
 export interface E2BExecutionResult {
@@ -20,6 +30,7 @@ export interface E2BExecutionResult {
   stdout: string
   sandboxId?: string
   error?: string
+  exportedFileContent?: string
   /** Base64-encoded PNG images captured from rich outputs (e.g. matplotlib figures). */
   images?: string[]
 }
@@ -27,7 +38,7 @@ export interface E2BExecutionResult {
 const logger = createLogger('E2BExecution')
 
 export async function executeInE2B(req: E2BExecutionRequest): Promise<E2BExecutionResult> {
-  const { code, language, timeoutMs } = req
+  const { code, language, timeoutMs, outputSandboxPath } = req
 
   const apiKey = env.E2B_API_KEY
   if (!apiKey) {
@@ -39,7 +50,15 @@ export async function executeInE2B(req: E2BExecutionRequest): Promise<E2BExecuti
 
   if (req.sandboxFiles?.length) {
     for (const file of req.sandboxFiles) {
-      await sandbox.files.write(file.path, file.content)
+      if (file.encoding === 'base64') {
+        const buf = Buffer.from(file.content, 'base64')
+        await sandbox.files.write(
+          file.path,
+          buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+        )
+      } else {
+        await sandbox.files.write(file.path, file.content)
+      }
     }
     logger.info('Wrote sandbox input files', {
       sandboxId,
@@ -115,7 +134,175 @@ export async function executeInE2B(req: E2BExecutionRequest): Promise<E2BExecuti
       }
     }
 
-    return { result, stdout: cleanedStdout, sandboxId, images: images.length ? images : undefined }
+    let exportedFileContent: string | undefined
+    if (outputSandboxPath) {
+      const ext = outputSandboxPath.slice(outputSandboxPath.lastIndexOf('.')).toLowerCase()
+      const binaryExts = new Set([
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.webp',
+        '.pdf',
+        '.zip',
+        '.mp3',
+        '.mp4',
+        '.docx',
+        '.pptx',
+        '.xlsx',
+      ])
+      if (binaryExts.has(ext)) {
+        const b64Result = await sandbox.commands.run(`base64 -w0 "${outputSandboxPath}"`)
+        exportedFileContent = b64Result.stdout
+      } else {
+        exportedFileContent = await sandbox.files.read(outputSandboxPath)
+      }
+    }
+
+    return {
+      result,
+      stdout: cleanedStdout,
+      sandboxId,
+      exportedFileContent,
+      images: images.length ? images : undefined,
+    }
+  } finally {
+    try {
+      await sandbox.kill()
+    } catch {}
+  }
+}
+
+export async function executeShellInE2B(
+  req: E2BShellExecutionRequest
+): Promise<E2BExecutionResult> {
+  const { code, envs, timeoutMs, outputSandboxPath } = req
+
+  const apiKey = env.E2B_API_KEY
+  if (!apiKey) {
+    throw new Error('E2B_API_KEY is required when E2B is enabled')
+  }
+
+  const templateName = env.MOTHERSHIP_E2B_TEMPLATE_ID
+  logger.info('Creating E2B shell sandbox', {
+    template: templateName || '(default)',
+  })
+  const sandbox = templateName
+    ? await Sandbox.create(templateName, { apiKey })
+    : await Sandbox.create({ apiKey })
+  const sandboxId = sandbox.sandboxId
+
+  if (req.sandboxFiles?.length) {
+    for (const file of req.sandboxFiles) {
+      if (file.encoding === 'base64') {
+        const buf = Buffer.from(file.content, 'base64')
+        await sandbox.files.write(
+          file.path,
+          buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+        )
+      } else {
+        await sandbox.files.write(file.path, file.content)
+      }
+    }
+    logger.info('Wrote sandbox input files', {
+      sandboxId,
+      fileCount: req.sandboxFiles.length,
+      paths: req.sandboxFiles.map((f) => f.path),
+    })
+  }
+
+  try {
+    let result: { stdout: string; stderr: string; exitCode: number }
+    try {
+      result = await sandbox.commands.run(code, {
+        envs: {
+          ...envs,
+          PATH: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/root/.local/bin',
+        },
+        timeoutMs,
+        user: 'root',
+      })
+    } catch (cmdError: any) {
+      const stderr = cmdError?.stderr || cmdError?.message || String(cmdError)
+      const stdout = cmdError?.stdout || ''
+      const exitCode = cmdError?.exitCode ?? 1
+      logger.error('E2B shell command error', {
+        sandboxId,
+        exitCode,
+        error: stderr.slice(0, 500),
+      })
+      return {
+        result: null,
+        stdout: [stdout, stderr].filter(Boolean).join('\n'),
+        error: stderr || `Command failed with exit code ${exitCode}`,
+        sandboxId,
+      }
+    }
+
+    const stdout = [result.stdout, result.stderr].filter(Boolean).join('\n')
+
+    if (result.exitCode !== 0) {
+      const errorMessage = result.stderr || `Process exited with code ${result.exitCode}`
+      logger.error('E2B shell execution error', {
+        sandboxId,
+        exitCode: result.exitCode,
+        stderr: result.stderr?.slice(0, 500),
+      })
+      return {
+        result: null,
+        stdout,
+        error: errorMessage,
+        sandboxId,
+      }
+    }
+
+    let parsed: unknown = null
+    const prefix = '__SIM_RESULT__='
+    const lines = stdout.split('\n')
+    const marker = lines.find((l) => l.startsWith(prefix))
+    let cleanedStdout = stdout
+    if (marker) {
+      const jsonPart = marker.slice(prefix.length)
+      try {
+        parsed = JSON.parse(jsonPart)
+      } catch {
+        parsed = jsonPart
+      }
+      const filteredLines = lines.filter((l) => !l.startsWith(prefix))
+      if (filteredLines.length > 0 && filteredLines[filteredLines.length - 1] === '') {
+        filteredLines.pop()
+      }
+      cleanedStdout = filteredLines.join('\n')
+    }
+
+    let exportedFileContent: string | undefined
+    if (outputSandboxPath) {
+      const ext = outputSandboxPath.slice(outputSandboxPath.lastIndexOf('.')).toLowerCase()
+      const binaryExts = new Set([
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.webp',
+        '.pdf',
+        '.zip',
+        '.mp3',
+        '.mp4',
+        '.docx',
+        '.pptx',
+        '.xlsx',
+      ])
+      if (binaryExts.has(ext)) {
+        const b64Result = await sandbox.commands.run(`base64 -w0 "${outputSandboxPath}"`, {
+          user: 'root',
+        })
+        exportedFileContent = b64Result.stdout
+      } else {
+        exportedFileContent = await sandbox.files.read(outputSandboxPath)
+      }
+    }
+
+    return { result: parsed, stdout: cleanedStdout, sandboxId, exportedFileContent }
   } finally {
     try {
       await sandbox.kill()
diff --git a/apps/sim/lib/execution/languages.ts b/apps/sim/lib/execution/languages.ts
index e25b991dd03..e664f23de96 100644
--- a/apps/sim/lib/execution/languages.ts
+++ b/apps/sim/lib/execution/languages.ts
@@ -4,6 +4,7 @@
 export enum CodeLanguage {
   JavaScript = 'javascript',
   Python = 'python',
+  Shell = 'shell',
 }
 
 /**
@@ -22,6 +23,8 @@ export function getLanguageDisplayName(language: CodeLanguage): string {
       return 'JavaScript'
     case CodeLanguage.Python:
       return 'Python'
+    case CodeLanguage.Shell:
+      return 'Shell'
     default:
       return language
   }
diff --git a/apps/sim/lib/mothership/inbox/executor.ts b/apps/sim/lib/mothership/inbox/executor.ts
index 1691861963d..afe95ebff72 100644
--- a/apps/sim/lib/mothership/inbox/executor.ts
+++ b/apps/sim/lib/mothership/inbox/executor.ts
@@ -1,14 +1,17 @@
 import { copilotChats, db, mothershipInboxTask, permissions, user, workspace } from '@sim/db'
 import { createLogger } from '@sim/logger'
 import { and, eq, sql } from 'drizzle-orm'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
-import { buildIntegrationToolSchemas } from '@/lib/copilot/chat-payload'
-import { requestChatTitle } from '@/lib/copilot/chat-streaming'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import type { OrchestratorResult } from '@/lib/copilot/orchestrator/types'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { generateWorkspaceContext } from '@/lib/copilot/workspace-context'
+import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
+import { buildIntegrationToolSchemas } from '@/lib/copilot/chat/payload'
+import {
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
+import { requestChatTitle } from '@/lib/copilot/request/lifecycle/start'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { isHosted } from '@/lib/core/config/feature-flags'
 import { generateId } from '@/lib/core/utils/uuid'
 import * as agentmail from '@/lib/mothership/inbox/agentmail-client'
@@ -189,27 +192,10 @@ export async function executeInboxTask(taskId: string): Promise<void> {
       ...(fileAttachments.length > 0 ? { fileAttachments } : {}),
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-    const runStreamId = generateId()
-
-    if (chatId) {
-      await createRunSegment({
-        id: runId,
-        executionId,
-        chatId,
-        userId,
-        workspaceId: ws.id,
-        streamId: runStreamId,
-      }).catch(() => {})
-    }
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runCopilotLifecycle(requestPayload, {
       userId,
       workspaceId: ws.id,
       chatId: chatId ?? undefined,
-      executionId,
-      runId,
       goRoute: '/api/mothership/execute',
       autoExecuteTools: true,
       interactive: false,
@@ -327,23 +313,13 @@ async function persistChatMessages(
   storedAttachments: StoredAttachment[] = []
 ): Promise<void> {
   try {
-    const now = new Date().toISOString()
-
-    const userMessage = {
+    const userMessage = buildPersistedUserMessage({
       id: userMessageId,
-      role: 'user' as const,
       content: userContent,
-      timestamp: now,
-      ...(storedAttachments.length > 0 ? { fileAttachments: storedAttachments } : {}),
-    }
+      fileAttachments: storedAttachments.length > 0 ? storedAttachments : undefined,
+    })
 
-    const assistantMessage = {
-      id: generateId(),
-      role: 'assistant' as const,
-      content: result.content || '',
-      timestamp: now,
-      ...(result.error ? { errorType: 'internal' } : {}),
-    }
+    const assistantMessage = buildPersistedAssistantMessage(result)
 
     const newMessages = JSON.stringify([userMessage, assistantMessage])
     await db
diff --git a/apps/sim/lib/notifications/inactivity-polling.ts b/apps/sim/lib/notifications/inactivity-polling.ts
index 63e0e248e02..6bcd1098dee 100644
--- a/apps/sim/lib/notifications/inactivity-polling.ts
+++ b/apps/sim/lib/notifications/inactivity-polling.ts
@@ -12,7 +12,6 @@ import { isTriggerDevEnabled } from '@/lib/core/config/feature-flags'
 import { generateId } from '@/lib/core/utils/uuid'
 import { TRIGGER_TYPES } from '@/lib/workflows/triggers/triggers'
 import {
-  enqueueNotificationDeliveryDispatch,
   executeNotificationDelivery,
   workspaceNotificationDeliveryTask,
 } from '@/background/workspace-notification-delivery'
@@ -196,7 +195,6 @@ async function checkWorkflowInactivity(
         `notificationType:${subscription.notificationType}`,
       ],
     })
-  } else if (await enqueueNotificationDeliveryDispatch(payload)) {
   } else {
     void executeNotificationDelivery(payload).catch((error) => {
       logger.error(`Direct notification delivery failed for ${deliveryId}`, { error })
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index ac947260909..59a7cfb900c 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -204,6 +204,49 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   yml: 'application/x-yaml',
   rtf: 'application/rtf',
 
+  // Code / plain-text source
+  py: 'text/x-python',
+  js: 'text/javascript',
+  mjs: 'text/javascript',
+  cjs: 'text/javascript',
+  ts: 'text/typescript',
+  tsx: 'text/typescript',
+  jsx: 'text/javascript',
+  go: 'text/x-go',
+  rs: 'text/x-rust',
+  java: 'text/x-java',
+  kt: 'text/x-kotlin',
+  c: 'text/x-c',
+  cpp: 'text/x-c++',
+  h: 'text/x-c',
+  hpp: 'text/x-c++',
+  cs: 'text/x-csharp',
+  rb: 'text/x-ruby',
+  php: 'text/x-php',
+  swift: 'text/x-swift',
+  sh: 'text/x-shellscript',
+  bash: 'text/x-shellscript',
+  zsh: 'text/x-shellscript',
+  r: 'text/x-r',
+  sql: 'text/x-sql',
+  scala: 'text/x-scala',
+  lua: 'text/x-lua',
+  pl: 'text/x-perl',
+  toml: 'text/x-toml',
+  ini: 'text/plain',
+  cfg: 'text/plain',
+  conf: 'text/plain',
+  env: 'text/plain',
+  log: 'text/plain',
+  makefile: 'text/x-makefile',
+  dockerfile: 'text/x-dockerfile',
+  css: 'text/css',
+  scss: 'text/x-scss',
+  less: 'text/x-less',
+  graphql: 'text/x-graphql',
+  gql: 'text/x-graphql',
+  proto: 'text/x-protobuf',
+
   // Audio
   mp3: 'audio/mpeg',
   m4a: 'audio/mp4',
diff --git a/apps/sim/next.config.ts b/apps/sim/next.config.ts
index e98d268c7bf..ab1805753ab 100644
--- a/apps/sim/next.config.ts
+++ b/apps/sim/next.config.ts
@@ -91,7 +91,12 @@ const nextConfig: NextConfig = {
   ],
   outputFileTracingIncludes: {
     '/api/tools/stagehand/*': ['./node_modules/ws/**/*'],
-    '/*': ['./node_modules/sharp/**/*', './node_modules/@img/**/*', './dist/pptx-worker.cjs'],
+    '/*': [
+      './node_modules/sharp/**/*',
+      './node_modules/@img/**/*',
+      './dist/pptx-worker.cjs',
+      './dist/doc-worker.cjs',
+    ],
   },
   experimental: {
     optimizeCss: true,
diff --git a/apps/sim/package.json b/apps/sim/package.json
index 0a8150656fe..40c63b850eb 100644
--- a/apps/sim/package.json
+++ b/apps/sim/package.json
@@ -16,8 +16,9 @@
     "load:workflow:baseline": "BASE_URL=${BASE_URL:-http://localhost:3000} WARMUP_DURATION=${WARMUP_DURATION:-10} WARMUP_RATE=${WARMUP_RATE:-2} PEAK_RATE=${PEAK_RATE:-8} HOLD_DURATION=${HOLD_DURATION:-20} bunx artillery run scripts/load/workflow-concurrency.yml",
     "load:workflow:waves": "BASE_URL=${BASE_URL:-http://localhost:3000} WAVE_ONE_DURATION=${WAVE_ONE_DURATION:-10} WAVE_ONE_RATE=${WAVE_ONE_RATE:-6} QUIET_DURATION=${QUIET_DURATION:-5} WAVE_TWO_DURATION=${WAVE_TWO_DURATION:-15} WAVE_TWO_RATE=${WAVE_TWO_RATE:-8} WAVE_THREE_DURATION=${WAVE_THREE_DURATION:-20} WAVE_THREE_RATE=${WAVE_THREE_RATE:-10} bunx artillery run scripts/load/workflow-waves.yml",
     "load:workflow:isolation": "BASE_URL=${BASE_URL:-http://localhost:3000} ISOLATION_DURATION=${ISOLATION_DURATION:-30} TOTAL_RATE=${TOTAL_RATE:-9} WORKSPACE_A_WEIGHT=${WORKSPACE_A_WEIGHT:-8} WORKSPACE_B_WEIGHT=${WORKSPACE_B_WEIGHT:-1} bunx artillery run scripts/load/workflow-isolation.yml",
-    "build": "bun run build:pptx-worker && next build",
+    "build": "bun run build:pptx-worker && bun run build:doc-worker && next build",
     "build:pptx-worker": "bun build ./lib/execution/pptx-worker.cjs --target=node --format=cjs --outfile ./dist/pptx-worker.cjs",
+    "build:doc-worker": "bun build ./lib/execution/doc-worker.cjs --target=node --format=cjs --outfile ./dist/doc-worker.cjs",
     "start": "next start",
     "worker": "NODE_ENV=production bun run worker/index.ts",
     "prepare": "cd ../.. && bun husky",
@@ -154,6 +155,8 @@
     "onedollarstats": "0.0.10",
     "openai": "^4.91.1",
     "papaparse": "5.5.3",
+    "docx": "^9.6.1",
+    "docx-preview": "^0.3.7",
     "pdf-lib": "1.17.1",
     "postgres": "^3.4.5",
     "posthog-js": "1.364.4",
diff --git a/apps/sim/stores/panel/copilot/types.ts b/apps/sim/stores/panel/copilot/types.ts
deleted file mode 100644
index 796cc53087e..00000000000
--- a/apps/sim/stores/panel/copilot/types.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import type { ServerToolUI } from '@/lib/copilot/store-utils'
-import type {
-  ClientToolCallState,
-  ClientToolDisplay,
-} from '@/lib/copilot/tools/client/tool-display-registry'
-import type { ChatContext as PanelChatContext } from '@/stores/panel/types'
-
-export type ChatContext = PanelChatContext
-
-export interface CopilotToolCall {
-  id: string
-  name: string
-  state: ClientToolCallState
-  display?: ClientToolDisplay
-  params?: Record<string, unknown>
-  input?: Record<string, unknown>
-  serverUI?: ServerToolUI
-  clientExecutable?: boolean
-  result?: { success: boolean; output?: unknown; error?: string }
-  error?: string
-  calledBy?: string
-  streamingArgs?: string
-}
-
-export interface SubAgentContentBlock {
-  type: string
-  content?: string
-  toolCall?: CopilotToolCall | null
-}
-
-export interface CopilotStreamInfo {
-  chatId?: string
-  streamId?: string
-  messageId?: string
-}
-
-export interface CopilotStore {
-  messages: Array<Record<string, unknown>>
-  toolCallsById: Record<string, CopilotToolCall>
-  activeStream: CopilotStreamInfo | null
-  streamingPlanContent?: string
-  handleNewChatCreation: (chatId: string) => Promise<void>
-  updatePlanTodoStatus: (todoId: string, status: string) => void
-  [key: string]: unknown
-}
-
-export type { ClientToolCallState, ClientToolDisplay }
diff --git a/apps/sim/stores/panel/index.ts b/apps/sim/stores/panel/index.ts
index cf2c541411f..5ce6320df74 100644
--- a/apps/sim/stores/panel/index.ts
+++ b/apps/sim/stores/panel/index.ts
@@ -1,8 +1,6 @@
 // Main panel store
 
 export { ClientToolCallState as ToolState } from '@/lib/copilot/tools/client/tool-display-registry'
-// Copilot types
-export type { CopilotToolCall } from './copilot/types'
 // Editor
 export { usePanelEditorStore } from './editor'
 export { usePanelStore } from './store'
diff --git a/apps/sim/tools/function/execute.ts b/apps/sim/tools/function/execute.ts
index d8e75ca55d3..844b1c6d515 100644
--- a/apps/sim/tools/function/execute.ts
+++ b/apps/sim/tools/function/execute.ts
@@ -7,7 +7,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
   id: 'function_execute',
   name: 'Function Execute',
   description:
-    'Execute JavaScript code. fetch() is available. Code runs in async IIFE wrapper automatically. CRITICAL: Write plain statements with await/return, NOT wrapped in functions. Example for API call: const res = await fetch(url); const data = await res.json(); return data;',
+    'Execute JavaScript, Python, or shell scripts in a secure sandbox. For JS: fetch() is available, code runs in async IIFE wrapper. For shell: workspace env vars available as $VAR_NAME, pre-installed CLI tools (jq, curl, awscli, psql, gh, etc.). Use outputPath/outputTable to persist returned data, or outputSandboxPath + outputPath to export a file created inside the sandbox into the workspace.',
   version: '1.0.0',
 
   params: {
@@ -22,7 +22,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
       type: 'string',
       required: false,
       visibility: 'user-only',
-      description: 'Language to execute (javascript or python)',
+      description: 'Language to execute (javascript, python, or shell)',
       default: DEFAULT_CODE_LANGUAGE,
     },
     timeout: {
@@ -32,6 +32,40 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
       description: 'Execution timeout in milliseconds',
       default: DEFAULT_EXECUTION_TIMEOUT_MS,
     },
+    outputPath: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'Write the tool result back to a workspace file, e.g. "files/result.json" or "files/report.csv". Use for text/JSON/CSV/markdown/html outputs.',
+    },
+    outputFormat: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description: 'Optional format override for outputPath (json, csv, txt, md, html).',
+    },
+    outputTable: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'Overwrite a workspace table with the code result. The code must return an array of objects.',
+    },
+    outputSandboxPath: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'Export a file created inside the sandbox to the workspace. Provide the sandbox file path here and also set outputPath to the workspace destination.',
+    },
+    outputMimeType: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'MIME type for the exported file. Required for binary files (e.g. "image/png", "application/pdf"). If omitted, inferred from outputPath extension for text formats.',
+    },
     envVars: {
       type: 'object',
       required: false,
@@ -84,6 +118,11 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         code: codeContent,
         language: params.language || DEFAULT_CODE_LANGUAGE,
         timeout: params.timeout || DEFAULT_EXECUTION_TIMEOUT_MS,
+        outputPath: params.outputPath,
+        outputFormat: params.outputFormat,
+        outputTable: params.outputTable,
+        outputSandboxPath: params.outputSandboxPath,
+        outputMimeType: params.outputMimeType,
         envVars: params.envVars || {},
         workflowVariables: params.workflowVariables || {},
         blockData: params.blockData || {},
@@ -91,6 +130,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         blockOutputSchemas: params.blockOutputSchemas || {},
         workflowId: params._context?.workflowId,
         userId: params._context?.userId,
+        workspaceId: params._context?.workspaceId,
         isCustomTool: params.isCustomTool || false,
       }
 
@@ -113,6 +153,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
           stdout: result.output?.stdout || '',
         },
         error: result.error,
+        resources: result.resources,
       }
     }
 
@@ -122,6 +163,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         result: result.output.result,
         stdout: result.output.stdout,
       },
+      resources: result.resources,
     }
   },
 
diff --git a/apps/sim/tools/function/types.ts b/apps/sim/tools/function/types.ts
index 0fea6bf7b23..9fb66875a35 100644
--- a/apps/sim/tools/function/types.ts
+++ b/apps/sim/tools/function/types.ts
@@ -7,6 +7,11 @@ export interface CodeExecutionInput {
   useLocalVM?: boolean
   timeout?: number
   memoryLimit?: number
+  outputPath?: string
+  outputFormat?: 'json' | 'csv' | 'txt' | 'md' | 'html'
+  outputTable?: string
+  outputSandboxPath?: string
+  outputMimeType?: string
   envVars?: Record<string, string>
   workflowVariables?: Record<string, unknown>
   blockData?: Record<string, unknown>
@@ -15,6 +20,7 @@ export interface CodeExecutionInput {
   _context?: {
     workflowId?: string
     userId?: string
+    workspaceId?: string
   }
   isCustomTool?: boolean
   _sandboxFiles?: Array<{ path: string; content: string }>
diff --git a/apps/sim/tools/index.ts b/apps/sim/tools/index.ts
index e48e05baf2d..ede5c818894 100644
--- a/apps/sim/tools/index.ts
+++ b/apps/sim/tools/index.ts
@@ -695,7 +695,6 @@ export async function executeTool(
     if (contextParams.oauthCredential) {
       contextParams.credential = contextParams.oauthCredential
     }
-
     if (contextParams.credential) {
       logger.info(
         `[${requestId}] Tool ${toolId} needs access token for credential: ${contextParams.credential}`
diff --git a/apps/sim/tools/types.ts b/apps/sim/tools/types.ts
index 48c44535f71..7758f6facc2 100644
--- a/apps/sim/tools/types.ts
+++ b/apps/sim/tools/types.ts
@@ -1,3 +1,4 @@
+import type { MothershipResource } from '@/lib/copilot/resources/types'
 import type { HostedKeyRateLimitConfig } from '@/lib/core/rate-limiter'
 import type { OAuthService } from '@/lib/oauth'
 
@@ -62,6 +63,7 @@ export interface ToolResponse {
   success: boolean // Whether the tool execution was successful
   output: Record<string, any> // The structured output from the tool
   error?: string // Error message if success is false
+  resources?: MothershipResource[] // Resources to auto-open/show in UI
   timing?: {
     startTime: string // ISO timestamp when the tool execution started
     endTime: string // ISO timestamp when the tool execution ended
diff --git a/apps/sim/trigger.config.ts b/apps/sim/trigger.config.ts
index 2f12cf3ab53..aab25af42be 100644
--- a/apps/sim/trigger.config.ts
+++ b/apps/sim/trigger.config.ts
@@ -15,10 +15,14 @@ export default defineConfig({
   },
   dirs: ['./background'],
   build: {
-    external: ['isolated-vm', 'pptxgenjs'],
+    external: ['isolated-vm', 'pptxgenjs', 'docx', 'pdf-lib'],
     extensions: [
       additionalFiles({
-        files: ['./lib/execution/isolated-vm-worker.cjs', './lib/execution/pptx-worker.cjs'],
+        files: [
+          './lib/execution/isolated-vm-worker.cjs',
+          './lib/execution/pptx-worker.cjs',
+          './lib/execution/doc-worker.cjs',
+        ],
       }),
       additionalPackages({
         packages: [
@@ -26,6 +30,7 @@ export default defineConfig({
           'pdf-lib',
           'isolated-vm',
           'pptxgenjs',
+          'docx',
           'react-dom',
           '@react-email/render',
         ],
diff --git a/bun.lock b/bun.lock
index e05bc532f5e..640d9891323 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "simstudio",
@@ -136,6 +135,8 @@
         "csv-parse": "6.1.0",
         "date-fns": "4.1.0",
         "decimal.js": "10.6.0",
+        "docx": "^9.6.1",
+        "docx-preview": "^0.3.7",
         "drizzle-orm": "^0.44.5",
         "encoding": "0.1.13",
         "entities": "6.0.1",
@@ -2124,6 +2125,10 @@
 
     "docs": ["docs@workspace:apps/docs"],
 
+    "docx": ["docx@9.6.1", "", { "dependencies": { "@types/node": "^25.2.3", "hash.js": "^1.1.7", "jszip": "^3.10.1", "nanoid": "^5.1.3", "xml": "^1.0.1", "xml-js": "^1.6.8" } }, "sha512-ZJja9/KBUuFC109sCMzovoq2GR2wCG/AuxivjA+OHj/q0TEgJIm3S7yrlUxIy3B+bV8YDj/BiHfWyrRFmyWpDQ=="],
+
+    "docx-preview": ["docx-preview@0.3.7", "", { "dependencies": { "jszip": ">=3.0.0" } }, "sha512-Lav69CTA/IYZPJTsKH7oYeoZjyg96N0wEJMNslGJnZJ+dMUZK85Lt5ASC79yUlD48ecWjuv+rkcmFt6EVPV0Xg=="],
+
     "dom-accessibility-api": ["dom-accessibility-api@0.6.3", "", {}, "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w=="],
 
     "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="],
@@ -2422,6 +2427,8 @@
 
     "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
 
+    "hash.js": ["hash.js@1.1.7", "", { "dependencies": { "inherits": "^2.0.3", "minimalistic-assert": "^1.0.1" } }, "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA=="],
+
     "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
 
     "hast-util-from-parse5": ["hast-util-from-parse5@8.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "devlop": "^1.0.0", "hastscript": "^9.0.0", "property-information": "^7.0.0", "vfile": "^6.0.0", "vfile-location": "^5.0.0", "web-namespaces": "^2.0.0" } }, "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg=="],
@@ -4606,6 +4613,8 @@
 
     "cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
 
+    "docx/@types/node": ["@types/node@25.5.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg=="],
+
     "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
     "e2b/glob": ["glob@11.1.0", "", { "dependencies": { "foreground-child": "^3.3.1", "jackspeak": "^4.1.1", "minimatch": "^10.1.1", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw=="],
@@ -5208,6 +5217,8 @@
 
     "critters/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
 
+    "docx/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
     "engine.io/@types/node/undici-types": ["undici-types@7.10.0", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
 
     "fetch-cookie/tough-cookie/tldts": ["tldts@7.0.27", "", { "dependencies": { "tldts-core": "^7.0.27" }, "bin": { "tldts": "bin/cli.js" } }, "sha512-I4FZcVFcqCRuT0ph6dCDpPuO4Xgzvh+spkcTr1gK7peIvxWauoloVO0vuy1FQnijT63ss6AsHB6+OIM4aXHbPg=="],
diff --git a/docker/app.Dockerfile b/docker/app.Dockerfile
index 54791300d58..688ac13ad19 100644
--- a/docker/app.Dockerfile
+++ b/docker/app.Dockerfile
@@ -117,8 +117,9 @@ COPY --from=deps --chown=nextjs:nodejs /app/node_modules/isolated-vm ./node_modu
 # Copy the isolated-vm worker script
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/lib/execution/isolated-vm-worker.cjs ./apps/sim/lib/execution/isolated-vm-worker.cjs
 
-# Copy the bundled PPTX worker artifact
+# Copy the bundled worker artifacts
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/dist/pptx-worker.cjs ./apps/sim/dist/pptx-worker.cjs
+COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/dist/doc-worker.cjs ./apps/sim/dist/doc-worker.cjs
 
 # Guardrails setup with pip caching
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/lib/guardrails/requirements.txt ./apps/sim/lib/guardrails/requirements.txt
diff --git a/package.json b/package.json
index c7ff404e8c2..74ceff2be6c 100644
--- a/package.json
+++ b/package.json
@@ -21,6 +21,14 @@
     "lint:helm": "helm lint ./helm/sim --strict --values ./helm/sim/test/values-lint.yaml",
     "lint:all": "turbo run lint && bun run lint:helm",
     "check": "turbo run format:check",
+    "mship-contracts:generate": "bun run scripts/sync-mothership-stream-contract.ts",
+    "mship-contracts:check": "bun run scripts/sync-mothership-stream-contract.ts --check",
+    "mship-tools:generate": "bun run scripts/sync-tool-catalog.ts",
+    "mship-tools:check": "bun run scripts/sync-tool-catalog.ts --check",
+    "trace-contracts:generate": "bun run scripts/sync-request-trace-contract.ts",
+    "trace-contracts:check": "bun run scripts/sync-request-trace-contract.ts --check",
+    "mship:generate": "bun run mship-contracts:generate && bun run mship-tools:generate && bun run trace-contracts:generate",
+    "mship:check": "bun run mship-contracts:check && bun run mship-tools:check && bun run trace-contracts:check",
     "prepare": "bun husky",
     "type-check": "turbo run type-check",
     "release": "bun run scripts/create-single-release.ts"
diff --git a/packages/testing/src/factories/dag.factory.ts b/packages/testing/src/factories/dag.factory.ts
index 2348a8e0480..2b3bdd74cf9 100644
--- a/packages/testing/src/factories/dag.factory.ts
+++ b/packages/testing/src/factories/dag.factory.ts
@@ -1,6 +1,6 @@
 /**
  * Factory functions for creating DAG (Directed Acyclic Graph) test fixtures.
- * These are used in executor tests for DAG construction and edge management.
+ * These are used in executor tests for DAG construction and edge management
  */
 
 import { createSerializedBlock, type SerializedBlock } from './serialized-block.factory'
diff --git a/scripts/sync-mothership-stream-contract.ts b/scripts/sync-mothership-stream-contract.ts
new file mode 100644
index 00000000000..0c0282b240d
--- /dev/null
+++ b/scripts/sync-mothership-stream-contract.ts
@@ -0,0 +1,68 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { compile } from 'json-schema-to-typescript'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DEFAULT_CONTRACT_PATH = resolve(
+  ROOT,
+  '../copilot/copilot/contracts/mothership-stream-v1.schema.json'
+)
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/mothership-stream-v1.ts')
+
+function generateRuntimeConstants(schema: Record<string, unknown>): string {
+  const defs = (schema.$defs ?? schema.definitions ?? {}) as Record<string, unknown>
+  const lines: string[] = []
+
+  for (const [name, def] of Object.entries(defs)) {
+    if (!def || typeof def !== 'object') continue
+    const defObj = def as Record<string, unknown>
+    const enumValues = defObj.enum
+    if (!Array.isArray(enumValues) || enumValues.length === 0) continue
+    if (!enumValues.every((v) => typeof v === 'string')) continue
+
+    const entries = (enumValues as string[])
+      .map((v) => `  ${JSON.stringify(v)}: ${JSON.stringify(v)}`)
+      .join(',\n')
+
+    lines.push(
+      `export const ${name} = {\n${entries},\n} as const;\n`
+    )
+  }
+
+  return lines.join('\n')
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+  const inputPathArg = process.argv.find((arg) => arg.startsWith('--input='))
+  const inputPath = inputPathArg ? resolve(ROOT, inputPathArg.slice('--input='.length)) : DEFAULT_CONTRACT_PATH
+
+  const raw = await readFile(inputPath, 'utf8')
+  const schema = JSON.parse(raw)
+  const types = await compile(schema, 'MothershipStreamV1EventEnvelope', {
+    bannerComment:
+      '// AUTO-GENERATED FILE. DO NOT EDIT.\n//',
+    unreachableDefinitions: true,
+    additionalProperties: false
+  })
+
+  const constants = generateRuntimeConstants(schema)
+  const rendered = constants ? `${types}\n${constants}\n` : types
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    if (existing !== rendered) {
+      throw new Error(
+        `Generated mothership stream contract is stale. Run: bun run mship-contracts:generate`
+      )
+    }
+    return
+  }
+
+  await mkdir(dirname(OUTPUT_PATH), { recursive: true })
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+}
+
+await main()
diff --git a/scripts/sync-request-trace-contract.ts b/scripts/sync-request-trace-contract.ts
new file mode 100644
index 00000000000..2cf7f5c3f05
--- /dev/null
+++ b/scripts/sync-request-trace-contract.ts
@@ -0,0 +1,73 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { compile } from 'json-schema-to-typescript'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DEFAULT_CONTRACT_PATH = resolve(
+  ROOT,
+  '../copilot/copilot/contracts/request-trace-v1.schema.json'
+)
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/request-trace-v1.ts')
+
+function generateRuntimeConstants(schema: Record<string, unknown>): string {
+  const defs = (schema.$defs ?? schema.definitions ?? {}) as Record<string, unknown>
+  const lines: string[] = []
+
+  for (const [name, def] of Object.entries(defs)) {
+    if (!def || typeof def !== 'object') continue
+    const defObj = def as Record<string, unknown>
+    const enumValues = defObj.enum
+    if (!Array.isArray(enumValues) || enumValues.length === 0) continue
+    if (!enumValues.every((v) => typeof v === 'string')) continue
+
+    const entries = (enumValues as string[])
+      .map((v) => `  ${JSON.stringify(v)}: ${JSON.stringify(v)}`)
+      .join(',\n')
+
+    lines.push(
+      `export const ${name} = {\n${entries},\n} as const;\n`
+    )
+  }
+
+  return lines.join('\n')
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+  const inputPathArg = process.argv.find((arg) => arg.startsWith('--input='))
+  const inputPath = inputPathArg ? resolve(ROOT, inputPathArg.slice('--input='.length)) : DEFAULT_CONTRACT_PATH
+
+  const raw = await readFile(inputPath, 'utf8')
+  const schema = JSON.parse(raw)
+  const types = await compile(schema, 'RequestTraceV1SimReport', {
+    bannerComment:
+      '// AUTO-GENERATED FILE. DO NOT EDIT.\n//',
+    unreachableDefinitions: true,
+    additionalProperties: false
+  })
+
+  const constants = generateRuntimeConstants(schema)
+  const rendered = constants ? `${types}\n${constants}\n` : types
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    if (existing !== rendered) {
+      throw new Error(
+        `Generated request trace contract is stale. Run: bun run trace-contracts:generate`
+      )
+    }
+    console.log('Request trace contract is up to date.')
+    return
+  }
+
+  await mkdir(dirname(OUTPUT_PATH), { recursive: true })
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+  console.log(`Generated request trace types -> ${OUTPUT_PATH}`)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})
diff --git a/scripts/sync-tool-catalog.ts b/scripts/sync-tool-catalog.ts
new file mode 100644
index 00000000000..657de6373f2
--- /dev/null
+++ b/scripts/sync-tool-catalog.ts
@@ -0,0 +1,157 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DEFAULT_CATALOG_PATH = resolve(
+  ROOT,
+  '../copilot/copilot/contracts/tool-catalog-v1.json'
+)
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/tool-catalog-v1.ts')
+const RUNTIME_SCHEMA_OUTPUT_PATH = resolve(
+  ROOT,
+  'apps/sim/lib/copilot/generated/tool-schemas-v1.ts'
+)
+
+function snakeToPascal(s: string): string {
+  return s.split('_').map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join('')
+}
+
+function inferTSType(values: unknown[]): string {
+  const unique = [...new Set(values.filter((v) => v !== undefined && v !== null))]
+  if (unique.length === 0) return 'string'
+  if (unique.every((v) => typeof v === 'string')) {
+    return unique.map((v) => JSON.stringify(v)).sort().join(' | ')
+  }
+  if (unique.every((v) => typeof v === 'boolean')) return 'boolean'
+  if (unique.every((v) => typeof v === 'number')) return 'number'
+  return 'unknown'
+}
+
+function renderRuntimeSchemaModule(catalog: { tools: Record<string, unknown>[] }): string {
+  const lines: string[] = [
+    '// AUTO-GENERATED FILE. DO NOT EDIT.',
+    '// Generated from copilot/contracts/tool-catalog-v1.json',
+    '//',
+    '',
+    'export type JsonSchema = unknown',
+    '',
+    'export interface ToolRuntimeSchemaEntry {',
+    '  parameters?: JsonSchema;',
+    '  resultSchema?: JsonSchema;',
+    '}',
+    '',
+    'export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {',
+  ]
+
+  for (const tool of catalog.tools) {
+    const id = JSON.stringify(tool.id)
+    const parameters = 'parameters' in tool ? JSON.stringify(tool.parameters ?? null, null, 2) : 'undefined'
+    const resultSchema =
+      'resultSchema' in tool ? JSON.stringify(tool.resultSchema ?? null, null, 2) : 'undefined'
+    lines.push(`  [${id}]: {`)
+    lines.push(
+      `    parameters: ${parameters === 'null' ? 'undefined' : parameters.replace(/\n/g, '\n    ')},`
+    )
+    lines.push(
+      `    resultSchema: ${resultSchema === 'null' ? 'undefined' : resultSchema.replace(/\n/g, '\n    ')},`
+    )
+    lines.push('  },')
+  }
+
+  lines.push('}')
+  lines.push('')
+  return lines.join('\n')
+}
+
+function generateInterface(tools: Record<string, unknown>[]): string {
+  if (tools.length === 0) return 'export interface ToolCatalogEntry {}\n'
+
+  const allKeys = new Set<string>()
+  for (const tool of tools) {
+    for (const key of Object.keys(tool)) {
+      allKeys.add(key)
+    }
+  }
+
+  const requiredKeys = new Set<string>()
+  for (const key of allKeys) {
+    if (tools.every((t) => key in t)) {
+      requiredKeys.add(key)
+    }
+  }
+
+  const lines: string[] = ['export interface ToolCatalogEntry {']
+  for (const key of [...allKeys].sort()) {
+    const values = tools.map((t) => t[key])
+    const tsType = inferTSType(values)
+    const optional = requiredKeys.has(key) ? '' : '?'
+    lines.push(`  ${key}${optional}: ${tsType};`)
+  }
+  lines.push('}')
+  return lines.join('\n')
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+  const inputPathArg = process.argv.find((arg) => arg.startsWith('--input='))
+  const inputPath = inputPathArg ? resolve(ROOT, inputPathArg.slice('--input='.length)) : DEFAULT_CATALOG_PATH
+
+  const raw = await readFile(inputPath, 'utf8')
+  const catalog = JSON.parse(raw) as { version: string; tools: Record<string, unknown>[] }
+
+  const iface = generateInterface(catalog.tools)
+
+  const lines: string[] = [
+    '// AUTO-GENERATED FILE. DO NOT EDIT.',
+    '// Generated from copilot/contracts/tool-catalog-v1.json',
+    '//',
+    '',
+    iface,
+    '',
+  ]
+
+  const constNames: string[] = []
+
+  for (const tool of catalog.tools) {
+    const constName = snakeToPascal(tool.id as string)
+    constNames.push(constName)
+    const fields: string[] = []
+    for (const [key, value] of Object.entries(tool)) {
+      fields.push(`  ${key}: ${JSON.stringify(value)}`)
+    }
+    lines.push(`export const ${constName}: ToolCatalogEntry = {`)
+    lines.push(fields.join(',\n') + ',')
+    lines.push('};')
+    lines.push('')
+  }
+
+  lines.push(`export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {`)
+  for (let i = 0; i < catalog.tools.length; i++) {
+    lines.push(`  [${constNames[i]}.id]: ${constNames[i]},`)
+  }
+  lines.push('};')
+  lines.push('')
+
+  const rendered = lines.join('\n')
+  const runtimeSchemaRendered = renderRuntimeSchemaModule(catalog)
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    const existingRuntime = await readFile(RUNTIME_SCHEMA_OUTPUT_PATH, 'utf8').catch(() => null)
+    if (existing !== rendered || existingRuntime !== runtimeSchemaRendered) {
+      throw new Error(
+        `Generated tool catalog is stale. Run: bun run mship-tools:generate`
+      )
+    }
+    return
+  }
+
+  await mkdir(dirname(OUTPUT_PATH), { recursive: true })
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+  await mkdir(dirname(RUNTIME_SCHEMA_OUTPUT_PATH), { recursive: true })
+  await writeFile(RUNTIME_SCHEMA_OUTPUT_PATH, runtimeSchemaRendered, 'utf8')
+}
+
+await main()