Checkpoint

apps/docs/components/icons.tsx

@@ -1157,21 +1157,6 @@ export function AirweaveIcon(props: SVGProps<SVGSVGElement>) {
   )
 }
 
-export function GoogleBooksIcon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg {...props} xmlns='http://www.w3.org/2000/svg' viewBox='0 0 478.633 540.068'>
-      <path
-        fill='#1C51A4'
-        d='M449.059,218.231L245.519,99.538l-0.061,193.23c0.031,1.504-0.368,2.977-1.166,4.204c-0.798,1.258-1.565,1.995-2.915,2.547c-1.35,0.552-2.792,0.706-4.204,0.399c-1.412-0.307-2.7-1.043-3.713-2.117l-69.166-70.609l-69.381,70.179c-1.013,0.982-2.301,1.657-3.652,1.903c-1.381,0.246-2.792,0.092-4.081-0.491c-1.289-0.583-1.626-0.522-2.394-1.749c-0.767-1.197-1.197-2.608-1.197-4.081L85.031,6.007l-2.915-1.289C43.973-11.638,0,16.409,0,59.891v420.306c0,46.029,49.312,74.782,88.775,51.767l360.285-210.138C488.491,298.782,488.491,241.246,449.059,218.231z'
-      />
-      <path
-        fill='#80D7FB'
-        d='M88.805,8.124c-2.179-1.289-4.419-2.363-6.659-3.345l0.123,288.663c0,1.442,0.43,2.854,1.197,4.081c0.767,1.197,1.872,2.148,3.161,2.731c1.289,0.583,2.7,0.736,4.081,0.491c1.381-0.246,2.639-0.921,3.652-1.903l69.749-69.688l69.811,69.749c1.013,1.074,2.301,1.81,3.713,2.117c1.412,0.307,2.884,0.153,4.204-0.399c1.319-0.552,2.455-1.565,3.253-2.792c0.798-1.258,1.197-2.731,1.166-4.204V99.998L88.805,8.124z'
-      />
-    </svg>
-  )
-}
-
 export function GoogleDocsIcon(props: SVGProps<SVGSVGElement>) {
   return (
     <svg

apps/docs/components/ui/icon-mapping.ts

@@ -38,7 +38,6 @@ import {
   GithubIcon,
   GitLabIcon,
   GmailIcon,
-  GoogleBooksIcon,
   GoogleCalendarIcon,
   GoogleDocsIcon,
   GoogleDriveIcon,
@@ -173,7 +172,6 @@ export const blockTypeToIconMap: Record<string, IconComponent> = {
   github_v2: GithubIcon,
   gitlab: GitLabIcon,
   gmail_v2: GmailIcon,
-  google_books: GoogleBooksIcon,
   google_calendar_v2: GoogleCalendarIcon,
   google_docs: GoogleDocsIcon,
   google_drive: GoogleDriveIcon,

apps/docs/content/docs/en/tools/google_books.mdx

@@ -1,96 +0,0 @@
----
-title: Google Books
-description: Search and retrieve book information
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="google_books"
-  color="#FFFFFF"
-/>
-
-## Usage Instructions
-
-Search for books using the Google Books API. Find volumes by title, author, ISBN, or keywords, and retrieve detailed information about specific books including descriptions, ratings, and publication details.
-
-
-
-## Tools
-
-### `google_books_volume_search`
-
-Search for books using the Google Books API
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Google Books API key |
-| `query` | string | Yes | Search query. Supports special keywords: intitle:, inauthor:, inpublisher:, subject:, isbn: |
-| `filter` | string | No | Filter results by availability \(partial, full, free-ebooks, paid-ebooks, ebooks\) |
-| `printType` | string | No | Restrict to print type \(all, books, magazines\) |
-| `orderBy` | string | No | Sort order \(relevance, newest\) |
-| `startIndex` | number | No | Index of the first result to return \(for pagination\) |
-| `maxResults` | number | No | Maximum number of results to return \(1-40\) |
-| `langRestrict` | string | No | Restrict results to a specific language \(ISO 639-1 code\) |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `totalItems` | number | Total number of matching results |
-| `volumes` | array | List of matching volumes |
-|   ↳ `id` | string | Volume ID |
-|   ↳ `title` | string | Book title |
-|   ↳ `subtitle` | string | Book subtitle |
-|   ↳ `authors` | array | List of authors |
-|   ↳ `publisher` | string | Publisher name |
-|   ↳ `publishedDate` | string | Publication date |
-|   ↳ `description` | string | Book description |
-|   ↳ `pageCount` | number | Number of pages |
-|   ↳ `categories` | array | Book categories |
-|   ↳ `averageRating` | number | Average rating \(1-5\) |
-|   ↳ `ratingsCount` | number | Number of ratings |
-|   ↳ `language` | string | Language code |
-|   ↳ `previewLink` | string | Link to preview on Google Books |
-|   ↳ `infoLink` | string | Link to info page |
-|   ↳ `thumbnailUrl` | string | Book cover thumbnail URL |
-|   ↳ `isbn10` | string | ISBN-10 identifier |
-|   ↳ `isbn13` | string | ISBN-13 identifier |
-
-### `google_books_volume_details`
-
-Get detailed information about a specific book volume
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Google Books API key |
-| `volumeId` | string | Yes | The ID of the volume to retrieve |
-| `projection` | string | No | Projection level \(full, lite\) |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `id` | string | Volume ID |
-| `title` | string | Book title |
-| `subtitle` | string | Book subtitle |
-| `authors` | array | List of authors |
-| `publisher` | string | Publisher name |
-| `publishedDate` | string | Publication date |
-| `description` | string | Book description |
-| `pageCount` | number | Number of pages |
-| `categories` | array | Book categories |
-| `averageRating` | number | Average rating \(1-5\) |
-| `ratingsCount` | number | Number of ratings |
-| `language` | string | Language code |
-| `previewLink` | string | Link to preview on Google Books |
-| `infoLink` | string | Link to info page |
-| `thumbnailUrl` | string | Book cover thumbnail URL |
-| `isbn10` | string | ISBN-10 identifier |
-| `isbn13` | string | ISBN-13 identifier |
-
-

apps/docs/content/docs/en/tools/meta.json

@@ -33,7 +33,6 @@
     "github",
     "gitlab",
     "gmail",
-    "google_books",
     "google_calendar",
     "google_docs",
     "google_drive",

apps/sim/.env.example

@@ -13,7 +13,6 @@ BETTER_AUTH_URL=http://localhost:3000
 
 # NextJS (Required)
 NEXT_PUBLIC_APP_URL=http://localhost:3000
-# INTERNAL_API_BASE_URL=http://sim-app.default.svc.cluster.local:3000  # Optional: internal URL for server-side /api self-calls; defaults to NEXT_PUBLIC_APP_URL
 
 # Security (Required)
 ENCRYPTION_KEY=your_encryption_key  # Use `openssl rand -hex 32` to generate, used to encrypt environment variables

apps/sim/app/api/a2a/serve/[agentId]/utils.ts

@@ -1,7 +1,7 @@
 import type { Artifact, Message, PushNotificationConfig, Task, TaskState } from '@a2a-js/sdk'
 import { v4 as uuidv4 } from 'uuid'
 import { generateInternalToken } from '@/lib/auth/internal'
-import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { getBaseUrl } from '@/lib/core/utils/urls'
 
 /** A2A v0.3 JSON-RPC method names */
 export const A2A_METHODS = {
@@ -118,7 +118,7 @@ export interface ExecuteRequestResult {
 export async function buildExecuteRequest(
   config: ExecuteRequestConfig
 ): Promise<ExecuteRequestResult> {
-  const url = `${getInternalApiBaseUrl()}/api/workflows/${config.workflowId}/execute`
+  const url = `${getBaseUrl()}/api/workflows/${config.workflowId}/execute`
   const headers: Record<string, string> = { 'Content-Type': 'application/json' }
   let useInternalAuth = false
 

apps/sim/app/api/attribution/route.ts

@@ -1,187 +0,0 @@
-/**
- * POST /api/attribution
- *
- * Automatic UTM-based referral attribution.
- *
- * Reads the `sim_utm` cookie (set by proxy on auth pages), matches a campaign
- * by UTM specificity, and atomically inserts an attribution record + applies
- * bonus credits.
- *
- * Idempotent — the unique constraint on `userId` prevents double-attribution.
- */
-
-import { db } from '@sim/db'
-import { referralAttribution, referralCampaigns, userStats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { nanoid } from 'nanoid'
-import { cookies } from 'next/headers'
-import { NextResponse } from 'next/server'
-import { z } from 'zod'
-import { getSession } from '@/lib/auth'
-import { applyBonusCredits } from '@/lib/billing/credits/bonus'
-
-const logger = createLogger('AttributionAPI')
-
-const COOKIE_NAME = 'sim_utm'
-
-const UtmCookieSchema = z.object({
-  utm_source: z.string().optional(),
-  utm_medium: z.string().optional(),
-  utm_campaign: z.string().optional(),
-  utm_content: z.string().optional(),
-  referrer_url: z.string().optional(),
-  landing_page: z.string().optional(),
-  created_at: z.string().optional(),
-})
-
-/**
- * Finds the most specific active campaign matching the given UTM params.
- * Null fields on a campaign act as wildcards. Ties broken by newest campaign.
- */
-async function findMatchingCampaign(utmData: z.infer<typeof UtmCookieSchema>) {
-  const campaigns = await db
-    .select()
-    .from(referralCampaigns)
-    .where(eq(referralCampaigns.isActive, true))
-
-  let bestMatch: (typeof campaigns)[number] | null = null
-  let bestScore = -1
-
-  for (const campaign of campaigns) {
-    let score = 0
-    let mismatch = false
-
-    const fields = [
-      { campaignVal: campaign.utmSource, utmVal: utmData.utm_source },
-      { campaignVal: campaign.utmMedium, utmVal: utmData.utm_medium },
-      { campaignVal: campaign.utmCampaign, utmVal: utmData.utm_campaign },
-      { campaignVal: campaign.utmContent, utmVal: utmData.utm_content },
-    ] as const
-
-    for (const { campaignVal, utmVal } of fields) {
-      if (campaignVal === null) continue
-      if (campaignVal === utmVal) {
-        score++
-      } else {
-        mismatch = true
-        break
-      }
-    }
-
-    if (!mismatch && score > 0) {
-      if (
-        score > bestScore ||
-        (score === bestScore &&
-          bestMatch &&
-          campaign.createdAt.getTime() > bestMatch.createdAt.getTime())
-      ) {
-        bestScore = score
-        bestMatch = campaign
-      }
-    }
-  }
-
-  return bestMatch
-}
-
-export async function POST() {
-  try {
-    const session = await getSession()
-    if (!session?.user?.id) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const cookieStore = await cookies()
-    const utmCookie = cookieStore.get(COOKIE_NAME)
-    if (!utmCookie?.value) {
-      return NextResponse.json({ attributed: false, reason: 'no_utm_cookie' })
-    }
-
-    let utmData: z.infer<typeof UtmCookieSchema>
-    try {
-      let decoded: string
-      try {
-        decoded = decodeURIComponent(utmCookie.value)
-      } catch {
-        decoded = utmCookie.value
-      }
-      utmData = UtmCookieSchema.parse(JSON.parse(decoded))
-    } catch {
-      logger.warn('Failed to parse UTM cookie', { userId: session.user.id })
-      cookieStore.delete(COOKIE_NAME)
-      return NextResponse.json({ attributed: false, reason: 'invalid_cookie' })
-    }
-
-    const matchedCampaign = await findMatchingCampaign(utmData)
-    if (!matchedCampaign) {
-      cookieStore.delete(COOKIE_NAME)
-      return NextResponse.json({ attributed: false, reason: 'no_matching_campaign' })
-    }
-
-    const bonusAmount = Number(matchedCampaign.bonusCreditAmount)
-
-    let attributed = false
-    await db.transaction(async (tx) => {
-      const [existingStats] = await tx
-        .select({ id: userStats.id })
-        .from(userStats)
-        .where(eq(userStats.userId, session.user.id))
-        .limit(1)
-
-      if (!existingStats) {
-        await tx.insert(userStats).values({
-          id: nanoid(),
-          userId: session.user.id,
-        })
-      }
-
-      const result = await tx
-        .insert(referralAttribution)
-        .values({
-          id: nanoid(),
-          userId: session.user.id,
-          campaignId: matchedCampaign.id,
-          utmSource: utmData.utm_source || null,
-          utmMedium: utmData.utm_medium || null,
-          utmCampaign: utmData.utm_campaign || null,
-          utmContent: utmData.utm_content || null,
-          referrerUrl: utmData.referrer_url || null,
-          landingPage: utmData.landing_page || null,
-          bonusCreditAmount: bonusAmount.toString(),
-        })
-        .onConflictDoNothing({ target: referralAttribution.userId })
-        .returning({ id: referralAttribution.id })
-
-      if (result.length > 0) {
-        await applyBonusCredits(session.user.id, bonusAmount, tx)
-        attributed = true
-      }
-    })
-
-    if (attributed) {
-      logger.info('Referral attribution created and bonus credits applied', {
-        userId: session.user.id,
-        campaignId: matchedCampaign.id,
-        campaignName: matchedCampaign.name,
-        utmSource: utmData.utm_source,
-        utmCampaign: utmData.utm_campaign,
-        utmContent: utmData.utm_content,
-        bonusAmount,
-      })
-    } else {
-      logger.info('User already attributed, skipping', { userId: session.user.id })
-    }
-
-    cookieStore.delete(COOKIE_NAME)
-
-    return NextResponse.json({
-      attributed,
-      bonusAmount: attributed ? bonusAmount : undefined,
-      reason: attributed ? undefined : 'already_attributed',
-    })
-  } catch (error) {
-    logger.error('Attribution error', { error })
-    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
-  }
-}

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

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

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

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

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

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

apps/sim/app/api/copilot/checkpoints/revert/route.test.ts

@@ -18,9 +18,9 @@ describe('Copilot Checkpoints Revert API Route', () => {
     setupCommonApiMocks()
     mockCryptoUuid()
 
+    // Mock getBaseUrl to return localhost for tests
     vi.doMock('@/lib/core/utils/urls', () => ({
       getBaseUrl: vi.fn(() => 'http://localhost:3000'),
-      getInternalApiBaseUrl: vi.fn(() => 'http://localhost:3000'),
       getBaseDomain: vi.fn(() => 'localhost:3000'),
       getEmailDomain: vi.fn(() => 'localhost:3000'),
     }))

apps/sim/app/api/copilot/checkpoints/revert/route.ts

@@ -11,7 +11,7 @@ import {
   createRequestTracker,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request-helpers'
-import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { getBaseUrl } from '@/lib/core/utils/urls'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 import { isUuidV4 } from '@/executor/constants'
 
@@ -99,7 +99,7 @@ export async function POST(request: NextRequest) {
     }
 
     const stateResponse = await fetch(
-      `${getInternalApiBaseUrl()}/api/workflows/${checkpoint.workflowId}/state`,
+      `${getBaseUrl()}/api/workflows/${checkpoint.workflowId}/state`,
       {
         method: 'PUT',
         headers: {

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

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

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

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

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

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

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

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

apps/sim/app/api/mcp/serve/[serverId]/route.test.ts

@@ -72,7 +72,6 @@ describe('MCP Serve Route', () => {
     }))
     vi.doMock('@/lib/core/utils/urls', () => ({
       getBaseUrl: () => 'http://localhost:3000',
-      getInternalApiBaseUrl: () => 'http://localhost:3000',
     }))
     vi.doMock('@/lib/core/execution-limits', () => ({
       getMaxExecutionTimeout: () => 10_000,

apps/sim/app/api/mcp/serve/[serverId]/route.ts

@@ -22,7 +22,7 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { type AuthResult, checkHybridAuth } from '@/lib/auth/hybrid'
 import { generateInternalToken } from '@/lib/auth/internal'
 import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
-import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { getBaseUrl } from '@/lib/core/utils/urls'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('WorkflowMcpServeAPI')
@@ -285,7 +285,7 @@ async function handleToolsCall(
       )
     }
 
-    const executeUrl = `${getInternalApiBaseUrl()}/api/workflows/${tool.workflowId}/execute`
+    const executeUrl = `${getBaseUrl()}/api/workflows/${tool.workflowId}/execute`
     const headers: Record<string, string> = { 'Content-Type': 'application/json' }
 
     if (publicServerOwnerId) {

apps/sim/app/api/referral-code/redeem/route.ts

@@ -1,170 +0,0 @@
-/**
- * POST /api/referral-code/redeem
- *
- * Redeem a referral/promo code to receive bonus credits.
- *
- * Body:
- *   - code: string — The referral code to redeem
- *
- * Response: { redeemed: boolean, bonusAmount?: number, error?: string }
- *
- * Constraints:
- *   - Enterprise users cannot redeem codes
- *   - One redemption per user, ever (unique constraint on userId)
- *   - One redemption per organization for team users (partial unique on organizationId)
- */
-
-import { db } from '@sim/db'
-import { referralAttribution, referralCampaigns, userStats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, eq } from 'drizzle-orm'
-import { nanoid } from 'nanoid'
-import { NextResponse } from 'next/server'
-import { z } from 'zod'
-import { getSession } from '@/lib/auth'
-import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
-import { applyBonusCredits } from '@/lib/billing/credits/bonus'
-
-const logger = createLogger('ReferralCodeRedemption')
-
-const RedeemCodeSchema = z.object({
-  code: z.string().min(1, 'Code is required'),
-})
-
-export async function POST(request: Request) {
-  try {
-    const session = await getSession()
-    if (!session?.user?.id) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const body = await request.json()
-    const { code } = RedeemCodeSchema.parse(body)
-
-    const subscription = await getHighestPrioritySubscription(session.user.id)
-
-    if (subscription?.plan === 'enterprise') {
-      return NextResponse.json({
-        redeemed: false,
-        error: 'Enterprise accounts cannot redeem referral codes',
-      })
-    }
-
-    const isTeam = subscription?.plan === 'team'
-    const orgId = isTeam ? subscription.referenceId : null
-
-    const normalizedCode = code.trim().toUpperCase()
-
-    const [campaign] = await db
-      .select()
-      .from(referralCampaigns)
-      .where(and(eq(referralCampaigns.code, normalizedCode), eq(referralCampaigns.isActive, true)))
-      .limit(1)
-
-    if (!campaign) {
-      logger.info('Invalid code redemption attempt', {
-        userId: session.user.id,
-        code: normalizedCode,
-      })
-      return NextResponse.json({ error: 'Invalid or expired code' }, { status: 404 })
-    }
-
-    const [existingUserAttribution] = await db
-      .select({ id: referralAttribution.id })
-      .from(referralAttribution)
-      .where(eq(referralAttribution.userId, session.user.id))
-      .limit(1)
-
-    if (existingUserAttribution) {
-      return NextResponse.json({
-        redeemed: false,
-        error: 'You have already redeemed a code',
-      })
-    }
-
-    if (orgId) {
-      const [existingOrgAttribution] = await db
-        .select({ id: referralAttribution.id })
-        .from(referralAttribution)
-        .where(eq(referralAttribution.organizationId, orgId))
-        .limit(1)
-
-      if (existingOrgAttribution) {
-        return NextResponse.json({
-          redeemed: false,
-          error: 'A code has already been redeemed for your organization',
-        })
-      }
-    }
-
-    const bonusAmount = Number(campaign.bonusCreditAmount)
-
-    let redeemed = false
-    await db.transaction(async (tx) => {
-      const [existingStats] = await tx
-        .select({ id: userStats.id })
-        .from(userStats)
-        .where(eq(userStats.userId, session.user.id))
-        .limit(1)
-
-      if (!existingStats) {
-        await tx.insert(userStats).values({
-          id: nanoid(),
-          userId: session.user.id,
-        })
-      }
-
-      const result = await tx
-        .insert(referralAttribution)
-        .values({
-          id: nanoid(),
-          userId: session.user.id,
-          organizationId: orgId,
-          campaignId: campaign.id,
-          utmSource: null,
-          utmMedium: null,
-          utmCampaign: null,
-          utmContent: null,
-          referrerUrl: null,
-          landingPage: null,
-          bonusCreditAmount: bonusAmount.toString(),
-        })
-        .onConflictDoNothing()
-        .returning({ id: referralAttribution.id })
-
-      if (result.length > 0) {
-        await applyBonusCredits(session.user.id, bonusAmount, tx)
-        redeemed = true
-      }
-    })
-
-    if (redeemed) {
-      logger.info('Referral code redeemed', {
-        userId: session.user.id,
-        organizationId: orgId,
-        code: normalizedCode,
-        campaignId: campaign.id,
-        campaignName: campaign.name,
-        bonusAmount,
-      })
-    }
-
-    if (!redeemed) {
-      return NextResponse.json({
-        redeemed: false,
-        error: 'You have already redeemed a code',
-      })
-    }
-
-    return NextResponse.json({
-      redeemed: true,
-      bonusAmount,
-    })
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return NextResponse.json({ error: error.errors[0].message }, { status: 400 })
-    }
-    logger.error('Referral code redemption error', { error })
-    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
-  }
-}

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

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

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

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

apps/sim/app/api/templates/[id]/use/route.ts

@@ -6,7 +6,7 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { v4 as uuidv4 } from 'uuid'
 import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
-import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { getBaseUrl } from '@/lib/core/utils/urls'
 import {
   type RegenerateStateInput,
   regenerateWorkflowStateIds,
@@ -115,9 +115,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     // Step 3: Save the workflow state using the existing state endpoint (like imports do)
     // Ensure variables in state are remapped for the new workflow as well
     const workflowStateWithVariables = { ...workflowState, variables: remappedVariables }
-    const stateResponse = await fetch(
+    const stateResponse = await fetch(`${getBaseUrl()}/api/workflows/${newWorkflowId}/state`, {
-      `${getInternalApiBaseUrl()}/api/workflows/${newWorkflowId}/state`,
-      {
       method: 'PUT',
       headers: {
         'Content-Type': 'application/json',
@@ -125,8 +123,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
         cookie: request.headers.get('cookie') || '',
       },
       body: JSON.stringify(workflowStateWithVariables),
-      }
+    })
-    )
 
     if (!stateResponse.ok) {
       logger.error(`[${requestId}] Failed to save workflow state for template use`)

apps/sim/app/api/v1/admin/index.ts

@@ -66,12 +66,6 @@
  *   Credits:
  *   POST   /api/v1/admin/credits                            - Issue credits to user (by userId or email)
  *
- *   Referral Campaigns:
- *   GET    /api/v1/admin/referral-campaigns                 - List campaigns (?active=true/false)
- *   POST   /api/v1/admin/referral-campaigns                 - Create campaign
- *   GET    /api/v1/admin/referral-campaigns/:id             - Get campaign details
- *   PATCH  /api/v1/admin/referral-campaigns/:id             - Update campaign fields
- *
  *   Access Control (Permission Groups):
  *   GET    /api/v1/admin/access-control                     - List permission groups (?organizationId=X)
  *   DELETE /api/v1/admin/access-control                     - Delete permission groups for org (?organizationId=X)
@@ -103,7 +97,6 @@ export type {
   AdminOrganization,
   AdminOrganizationBillingSummary,
   AdminOrganizationDetail,
-  AdminReferralCampaign,
   AdminSeatAnalytics,
   AdminSingleResponse,
   AdminSubscription,
@@ -118,7 +111,6 @@ export type {
   AdminWorkspaceMember,
   DbMember,
   DbOrganization,
-  DbReferralCampaign,
   DbSubscription,
   DbUser,
   DbUserStats,
@@ -147,7 +139,6 @@ export {
   parseWorkflowVariables,
   toAdminFolder,
   toAdminOrganization,
-  toAdminReferralCampaign,
   toAdminSubscription,
   toAdminUser,
   toAdminWorkflow,

apps/sim/app/api/v1/admin/referral-campaigns/[id]/route.ts

@@ -1,142 +0,0 @@
-/**
- * GET   /api/v1/admin/referral-campaigns/:id
- *
- * Get a single referral campaign by ID.
- *
- * PATCH /api/v1/admin/referral-campaigns/:id
- *
- * Update campaign fields. All fields are optional.
- *
- * Body:
- *   - name: string (non-empty) - Campaign name
- *   - bonusCreditAmount: number (> 0) - Bonus credits in dollars
- *   - isActive: boolean - Enable/disable the campaign
- *   - code: string | null (min 6 chars, auto-uppercased, null to remove) - Redeemable code
- *   - utmSource: string | null - UTM source match (null = wildcard)
- *   - utmMedium: string | null - UTM medium match (null = wildcard)
- *   - utmCampaign: string | null - UTM campaign match (null = wildcard)
- *   - utmContent: string | null - UTM content match (null = wildcard)
- */
-
-import { db } from '@sim/db'
-import { referralCampaigns } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { getBaseUrl } from '@/lib/core/utils/urls'
-import { withAdminAuthParams } from '@/app/api/v1/admin/middleware'
-import {
-  badRequestResponse,
-  internalErrorResponse,
-  notFoundResponse,
-  singleResponse,
-} from '@/app/api/v1/admin/responses'
-import { toAdminReferralCampaign } from '@/app/api/v1/admin/types'
-
-const logger = createLogger('AdminReferralCampaignDetailAPI')
-
-interface RouteParams {
-  id: string
-}
-
-export const GET = withAdminAuthParams<RouteParams>(async (_, context) => {
-  try {
-    const { id: campaignId } = await context.params
-
-    const [campaign] = await db
-      .select()
-      .from(referralCampaigns)
-      .where(eq(referralCampaigns.id, campaignId))
-      .limit(1)
-
-    if (!campaign) {
-      return notFoundResponse('Campaign')
-    }
-
-    logger.info(`Admin API: Retrieved referral campaign ${campaignId}`)
-
-    return singleResponse(toAdminReferralCampaign(campaign, getBaseUrl()))
-  } catch (error) {
-    logger.error('Admin API: Failed to get referral campaign', { error })
-    return internalErrorResponse('Failed to get referral campaign')
-  }
-})
-
-export const PATCH = withAdminAuthParams<RouteParams>(async (request, context) => {
-  try {
-    const { id: campaignId } = await context.params
-    const body = await request.json()
-
-    const [existing] = await db
-      .select()
-      .from(referralCampaigns)
-      .where(eq(referralCampaigns.id, campaignId))
-      .limit(1)
-
-    if (!existing) {
-      return notFoundResponse('Campaign')
-    }
-
-    const updateData: Record<string, unknown> = { updatedAt: new Date() }
-
-    if (body.name !== undefined) {
-      if (typeof body.name !== 'string' || body.name.trim().length === 0) {
-        return badRequestResponse('name must be a non-empty string')
-      }
-      updateData.name = body.name.trim()
-    }
-
-    if (body.bonusCreditAmount !== undefined) {
-      if (
-        typeof body.bonusCreditAmount !== 'number' ||
-        !Number.isFinite(body.bonusCreditAmount) ||
-        body.bonusCreditAmount <= 0
-      ) {
-        return badRequestResponse('bonusCreditAmount must be a positive number')
-      }
-      updateData.bonusCreditAmount = body.bonusCreditAmount.toString()
-    }
-
-    if (body.isActive !== undefined) {
-      if (typeof body.isActive !== 'boolean') {
-        return badRequestResponse('isActive must be a boolean')
-      }
-      updateData.isActive = body.isActive
-    }
-
-    if (body.code !== undefined) {
-      if (body.code !== null) {
-        if (typeof body.code !== 'string') {
-          return badRequestResponse('code must be a string or null')
-        }
-        if (body.code.trim().length < 6) {
-          return badRequestResponse('code must be at least 6 characters')
-        }
-      }
-      updateData.code = body.code ? body.code.trim().toUpperCase() : null
-    }
-
-    for (const field of ['utmSource', 'utmMedium', 'utmCampaign', 'utmContent'] as const) {
-      if (body[field] !== undefined) {
-        if (body[field] !== null && typeof body[field] !== 'string') {
-          return badRequestResponse(`${field} must be a string or null`)
-        }
-        updateData[field] = body[field] || null
-      }
-    }
-
-    const [updated] = await db
-      .update(referralCampaigns)
-      .set(updateData)
-      .where(eq(referralCampaigns.id, campaignId))
-      .returning()
-
-    logger.info(`Admin API: Updated referral campaign ${campaignId}`, {
-      fields: Object.keys(updateData).filter((k) => k !== 'updatedAt'),
-    })
-
-    return singleResponse(toAdminReferralCampaign(updated, getBaseUrl()))
-  } catch (error) {
-    logger.error('Admin API: Failed to update referral campaign', { error })
-    return internalErrorResponse('Failed to update referral campaign')
-  }
-})

apps/sim/app/api/v1/admin/referral-campaigns/route.ts

@@ -1,140 +0,0 @@
-/**
- * GET  /api/v1/admin/referral-campaigns
- *
- * List referral campaigns with optional filtering and pagination.
- *
- * Query Parameters:
- *   - active: string (optional) - Filter by active status ('true' or 'false')
- *   - limit: number (default: 50, max: 250)
- *   - offset: number (default: 0)
- *
- * POST /api/v1/admin/referral-campaigns
- *
- * Create a new referral campaign.
- *
- * Body:
- *   - name: string (required) - Campaign name
- *   - bonusCreditAmount: number (required, > 0) - Bonus credits in dollars
- *   - code: string | null (optional, min 6 chars, auto-uppercased) - Redeemable code
- *   - utmSource: string | null (optional) - UTM source match (null = wildcard)
- *   - utmMedium: string | null (optional) - UTM medium match (null = wildcard)
- *   - utmCampaign: string | null (optional) - UTM campaign match (null = wildcard)
- *   - utmContent: string | null (optional) - UTM content match (null = wildcard)
- */
-
-import { db } from '@sim/db'
-import { referralCampaigns } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { count, eq, type SQL } from 'drizzle-orm'
-import { nanoid } from 'nanoid'
-import { getBaseUrl } from '@/lib/core/utils/urls'
-import { withAdminAuth } from '@/app/api/v1/admin/middleware'
-import {
-  badRequestResponse,
-  internalErrorResponse,
-  listResponse,
-  singleResponse,
-} from '@/app/api/v1/admin/responses'
-import {
-  type AdminReferralCampaign,
-  createPaginationMeta,
-  parsePaginationParams,
-  toAdminReferralCampaign,
-} from '@/app/api/v1/admin/types'
-
-const logger = createLogger('AdminReferralCampaignsAPI')
-
-export const GET = withAdminAuth(async (request) => {
-  const url = new URL(request.url)
-  const { limit, offset } = parsePaginationParams(url)
-  const activeFilter = url.searchParams.get('active')
-
-  try {
-    const conditions: SQL<unknown>[] = []
-    if (activeFilter === 'true') {
-      conditions.push(eq(referralCampaigns.isActive, true))
-    } else if (activeFilter === 'false') {
-      conditions.push(eq(referralCampaigns.isActive, false))
-    }
-
-    const whereClause = conditions.length > 0 ? conditions[0] : undefined
-    const baseUrl = getBaseUrl()
-
-    const [countResult, campaigns] = await Promise.all([
-      db.select({ total: count() }).from(referralCampaigns).where(whereClause),
-      db
-        .select()
-        .from(referralCampaigns)
-        .where(whereClause)
-        .orderBy(referralCampaigns.createdAt)
-        .limit(limit)
-        .offset(offset),
-    ])
-
-    const total = countResult[0].total
-    const data: AdminReferralCampaign[] = campaigns.map((c) => toAdminReferralCampaign(c, baseUrl))
-    const pagination = createPaginationMeta(total, limit, offset)
-
-    logger.info(`Admin API: Listed ${data.length} referral campaigns (total: ${total})`)
-
-    return listResponse(data, pagination)
-  } catch (error) {
-    logger.error('Admin API: Failed to list referral campaigns', { error })
-    return internalErrorResponse('Failed to list referral campaigns')
-  }
-})
-
-export const POST = withAdminAuth(async (request) => {
-  try {
-    const body = await request.json()
-    const { name, code, utmSource, utmMedium, utmCampaign, utmContent, bonusCreditAmount } = body
-
-    if (!name || typeof name !== 'string') {
-      return badRequestResponse('name is required and must be a string')
-    }
-
-    if (
-      typeof bonusCreditAmount !== 'number' ||
-      !Number.isFinite(bonusCreditAmount) ||
-      bonusCreditAmount <= 0
-    ) {
-      return badRequestResponse('bonusCreditAmount must be a positive number')
-    }
-
-    if (code !== undefined && code !== null) {
-      if (typeof code !== 'string') {
-        return badRequestResponse('code must be a string or null')
-      }
-      if (code.trim().length < 6) {
-        return badRequestResponse('code must be at least 6 characters')
-      }
-    }
-
-    const id = nanoid()
-
-    const [campaign] = await db
-      .insert(referralCampaigns)
-      .values({
-        id,
-        name,
-        code: code ? code.trim().toUpperCase() : null,
-        utmSource: utmSource || null,
-        utmMedium: utmMedium || null,
-        utmCampaign: utmCampaign || null,
-        utmContent: utmContent || null,
-        bonusCreditAmount: bonusCreditAmount.toString(),
-      })
-      .returning()
-
-    logger.info(`Admin API: Created referral campaign ${id}`, {
-      name,
-      code: campaign.code,
-      bonusCreditAmount,
-    })
-
-    return singleResponse(toAdminReferralCampaign(campaign, getBaseUrl()))
-  } catch (error) {
-    logger.error('Admin API: Failed to create referral campaign', { error })
-    return internalErrorResponse('Failed to create referral campaign')
-  }
-})

apps/sim/app/api/v1/admin/types.ts

@@ -8,7 +8,6 @@
 import type {
   member,
   organization,
-  referralCampaigns,
   subscription,
   user,
   userStats,
@@ -32,7 +31,6 @@ export type DbOrganization = InferSelectModel<typeof organization>
 export type DbSubscription = InferSelectModel<typeof subscription>
 export type DbMember = InferSelectModel<typeof member>
 export type DbUserStats = InferSelectModel<typeof userStats>
-export type DbReferralCampaign = InferSelectModel<typeof referralCampaigns>
 
 // =============================================================================
 // Pagination
@@ -648,49 +646,3 @@ export interface AdminDeployResult {
 export interface AdminUndeployResult {
   isDeployed: boolean
 }
-
-// =============================================================================
-// Referral Campaign Types
-// =============================================================================
-
-export interface AdminReferralCampaign {
-  id: string
-  name: string
-  code: string | null
-  utmSource: string | null
-  utmMedium: string | null
-  utmCampaign: string | null
-  utmContent: string | null
-  bonusCreditAmount: string
-  isActive: boolean
-  signupUrl: string | null
-  createdAt: string
-  updatedAt: string
-}
-
-export function toAdminReferralCampaign(
-  dbCampaign: DbReferralCampaign,
-  baseUrl: string
-): AdminReferralCampaign {
-  const utmParams = new URLSearchParams()
-  if (dbCampaign.utmSource) utmParams.set('utm_source', dbCampaign.utmSource)
-  if (dbCampaign.utmMedium) utmParams.set('utm_medium', dbCampaign.utmMedium)
-  if (dbCampaign.utmCampaign) utmParams.set('utm_campaign', dbCampaign.utmCampaign)
-  if (dbCampaign.utmContent) utmParams.set('utm_content', dbCampaign.utmContent)
-  const query = utmParams.toString()
-
-  return {
-    id: dbCampaign.id,
-    name: dbCampaign.name,
-    code: dbCampaign.code,
-    utmSource: dbCampaign.utmSource,
-    utmMedium: dbCampaign.utmMedium,
-    utmCampaign: dbCampaign.utmCampaign,
-    utmContent: dbCampaign.utmContent,
-    bonusCreditAmount: dbCampaign.bonusCreditAmount,
-    isActive: dbCampaign.isActive,
-    signupUrl: query ? `${baseUrl}/signup?${query}` : null,
-    createdAt: dbCampaign.createdAt.toISOString(),
-    updatedAt: dbCampaign.updatedAt.toISOString(),
-  }
-}

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

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

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

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

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

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

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

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

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

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

apps/sim/app/workspace/[workspaceId]/logs/components/dashboard/components/status-bar/index.ts

@@ -1,2 +1,2 @@
 export type { StatusBarSegment } from './status-bar'
-export { StatusBar } from './status-bar'
+export { default, StatusBar } from './status-bar'

apps/sim/app/workspace/[workspaceId]/logs/components/dashboard/components/status-bar/status-bar.tsx

@@ -8,7 +8,7 @@ export interface StatusBarSegment {
   timestamp: string
 }
 
-function StatusBarInner({
+export function StatusBar({
   segments,
   selectedSegmentIndices,
   onSegmentClick,
@@ -127,45 +127,4 @@ function StatusBarInner({
   )
 }
 
-/**
+export default memo(StatusBar)
- * Custom equality function for StatusBar memo.
- * Performs structural comparison of segments array to avoid re-renders
- * when poll data returns new object references with identical content.
- */
-function areStatusBarPropsEqual(
-  prev: Parameters<typeof StatusBarInner>[0],
-  next: Parameters<typeof StatusBarInner>[0]
-): boolean {
-  if (prev.workflowId !== next.workflowId) return false
-  if (prev.segmentDurationMs !== next.segmentDurationMs) return false
-  if (prev.preferBelow !== next.preferBelow) return false
-
-  if (prev.selectedSegmentIndices !== next.selectedSegmentIndices) {
-    if (!prev.selectedSegmentIndices || !next.selectedSegmentIndices) return false
-    if (prev.selectedSegmentIndices.length !== next.selectedSegmentIndices.length) return false
-    for (let i = 0; i < prev.selectedSegmentIndices.length; i++) {
-      if (prev.selectedSegmentIndices[i] !== next.selectedSegmentIndices[i]) return false
-    }
-  }
-
-  if (prev.segments !== next.segments) {
-    if (prev.segments.length !== next.segments.length) return false
-    for (let i = 0; i < prev.segments.length; i++) {
-      const ps = prev.segments[i]
-      const ns = next.segments[i]
-      if (
-        ps.successRate !== ns.successRate ||
-        ps.hasExecutions !== ns.hasExecutions ||
-        ps.totalExecutions !== ns.totalExecutions ||
-        ps.successfulExecutions !== ns.successfulExecutions ||
-        ps.timestamp !== ns.timestamp
-      ) {
-        return false
-      }
-    }
-  }
-
-  return true
-}
-
-export const StatusBar = memo(StatusBarInner, areStatusBarPropsEqual)

apps/sim/app/workspace/[workspaceId]/logs/components/dashboard/components/workflows-list/index.ts

@@ -1,2 +1,2 @@
 export type { WorkflowExecutionItem } from './workflows-list'
-export { WorkflowsList } from './workflows-list'
+export { default, WorkflowsList } from './workflows-list'

apps/sim/app/workspace/[workspaceId]/logs/components/dashboard/components/workflows-list/workflows-list.tsx

@@ -14,7 +14,7 @@ export interface WorkflowExecutionItem {
   overallSuccessRate: number
 }
 
-function WorkflowsListInner({
+export function WorkflowsList({
   filteredExecutions,
   expandedWorkflowId,
   onToggleWorkflow,
@@ -103,7 +103,7 @@ function WorkflowsListInner({
                     <StatusBar
                       segments={workflow.segments}
                       selectedSegmentIndices={selectedSegments[workflow.workflowId] || null}
-                      onSegmentClick={onSegmentClick}
+                      onSegmentClick={onSegmentClick as any}
                       workflowId={workflow.workflowId}
                       segmentDurationMs={segmentDurationMs}
                       preferBelow={idx < 2}
@@ -124,4 +124,4 @@ function WorkflowsListInner({
   )
 }
 
-export const WorkflowsList = memo(WorkflowsListInner)
+export default memo(WorkflowsList)

apps/sim/app/workspace/[workspaceId]/logs/components/dashboard/dashboard.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Loader2 } from 'lucide-react'
 import { Skeleton } from '@/components/ui/skeleton'
 import { formatLatency } from '@/app/workspace/[workspaceId]/logs/utils'
@@ -141,10 +141,10 @@ function toWorkflowExecution(wf: WorkflowStats): WorkflowExecution {
   }
 }
 
-function DashboardInner({ stats, isLoading, error }: DashboardProps) {
+export default function Dashboard({ stats, isLoading, error }: DashboardProps) {
   const [selectedSegments, setSelectedSegments] = useState<Record<string, number[]>>({})
   const [lastAnchorIndices, setLastAnchorIndices] = useState<Record<string, number>>({})
-  const lastAnchorIndicesRef = useRef<Record<string, number>>({})
+  const barsAreaRef = useRef<HTMLDivElement | null>(null)
 
   const { workflowIds, searchQuery, toggleWorkflowId, timeRange } = useFilterStore()
 
@@ -152,79 +152,20 @@ function DashboardInner({ stats, isLoading, error }: DashboardProps) {
 
   const expandedWorkflowId = workflowIds.length === 1 ? workflowIds[0] : null
 
-  const { rawExecutions, aggregateSegments, segmentMs } = useMemo(() => {
+  const { executions, aggregateSegments, segmentMs } = useMemo(() => {
     if (!stats) {
-      return { rawExecutions: [], aggregateSegments: [], segmentMs: 0 }
+      return { executions: [], aggregateSegments: [], segmentMs: 0 }
     }
 
+    const workflowExecutions = stats.workflows.map(toWorkflowExecution)
+
     return {
-      rawExecutions: stats.workflows.map(toWorkflowExecution),
+      executions: workflowExecutions,
       aggregateSegments: stats.aggregateSegments,
       segmentMs: stats.segmentMs,
     }
   }, [stats])
 
-  /**
-   * Stabilize execution objects: reuse previous references for workflows
-   * whose segment data hasn't structurally changed between polls.
-   * This prevents cascading re-renders through WorkflowsList → StatusBar.
-   */
-  const prevExecutionsRef = useRef<WorkflowExecution[]>([])
-
-  const executions = useMemo(() => {
-    const prevMap = new Map(prevExecutionsRef.current.map((e) => [e.workflowId, e]))
-    let anyChanged = false
-
-    const result = rawExecutions.map((exec) => {
-      const prev = prevMap.get(exec.workflowId)
-      if (!prev) {
-        anyChanged = true
-        return exec
-      }
-      if (
-        prev.overallSuccessRate !== exec.overallSuccessRate ||
-        prev.workflowName !== exec.workflowName ||
-        prev.segments.length !== exec.segments.length
-      ) {
-        anyChanged = true
-        return exec
-      }
-
-      for (let i = 0; i < prev.segments.length; i++) {
-        const ps = prev.segments[i]
-        const ns = exec.segments[i]
-        if (
-          ps.totalExecutions !== ns.totalExecutions ||
-          ps.successfulExecutions !== ns.successfulExecutions ||
-          ps.timestamp !== ns.timestamp ||
-          ps.avgDurationMs !== ns.avgDurationMs ||
-          ps.p50Ms !== ns.p50Ms ||
-          ps.p90Ms !== ns.p90Ms ||
-          ps.p99Ms !== ns.p99Ms
-        ) {
-          anyChanged = true
-          return exec
-        }
-      }
-
-      return prev
-    })
-
-    if (
-      !anyChanged &&
-      result.length === prevExecutionsRef.current.length &&
-      result.every((r, i) => r === prevExecutionsRef.current[i])
-    ) {
-      return prevExecutionsRef.current
-    }
-
-    return result
-  }, [rawExecutions])
-
-  useEffect(() => {
-    prevExecutionsRef.current = executions
-  }, [executions])
-
   const lastExecutionByWorkflow = useMemo(() => {
     const map = new Map<string, number>()
     for (const wf of executions) {
@@ -371,8 +312,6 @@ function DashboardInner({ stats, isLoading, error }: DashboardProps) {
     [toggleWorkflowId]
   )
 
-  lastAnchorIndicesRef.current = lastAnchorIndices
-
   /**
    * Handles segment click for selecting time segments.
    * @param workflowId - The workflow containing the segment
@@ -422,7 +361,7 @@ function DashboardInner({ stats, isLoading, error }: DashboardProps) {
       } else if (mode === 'range') {
         setSelectedSegments((prev) => {
           const currentSegments = prev[workflowId] || []
-          const anchor = lastAnchorIndicesRef.current[workflowId] ?? segmentIndex
+          const anchor = lastAnchorIndices[workflowId] ?? segmentIndex
           const [start, end] =
             anchor < segmentIndex ? [anchor, segmentIndex] : [segmentIndex, anchor]
           const range = Array.from({ length: end - start + 1 }, (_, i) => start + i)
@@ -431,12 +370,12 @@ function DashboardInner({ stats, isLoading, error }: DashboardProps) {
         })
       }
     },
-    []
+    [lastAnchorIndices]
   )
 
   useEffect(() => {
-    setSelectedSegments((prev) => (Object.keys(prev).length > 0 ? {} : prev))
+    setSelectedSegments({})
-    setLastAnchorIndices((prev) => (Object.keys(prev).length > 0 ? {} : prev))
+    setLastAnchorIndices({})
   }, [stats, timeRange, workflowIds, searchQuery])
 
   if (isLoading) {
@@ -554,7 +493,7 @@ function DashboardInner({ stats, isLoading, error }: DashboardProps) {
         </div>
       </div>
 
-      <div className='min-h-0 flex-1 overflow-hidden'>
+      <div className='min-h-0 flex-1 overflow-hidden' ref={barsAreaRef}>
         <WorkflowsList
           filteredExecutions={filteredExecutions as WorkflowExecution[]}
           expandedWorkflowId={expandedWorkflowId}
@@ -568,5 +507,3 @@ function DashboardInner({ stats, isLoading, error }: DashboardProps) {
     </div>
   )
 }
-
-export default memo(DashboardInner)

apps/sim/app/workspace/[workspaceId]/logs/components/log-details/log-details.tsx

@@ -43,12 +43,11 @@ import { useLogDetailsUIStore } from '@/stores/logs/store'
 /**
  * Workflow Output section with code viewer, copy, search, and context menu functionality
  */
-const WorkflowOutputSection = memo(
 function WorkflowOutputSection({ output }: { output: Record<string, unknown> }) {
   const contentRef = useRef<HTMLDivElement>(null)
   const [copied, setCopied] = useState(false)
-    const copyTimerRef = useRef<number | null>(null)
 
+  // Context menu state
   const [isContextMenuOpen, setIsContextMenuOpen] = useState(false)
   const [contextMenuPosition, setContextMenuPosition] = useState({ x: 0, y: 0 })
 
@@ -82,17 +81,10 @@ const WorkflowOutputSection = memo(
   const handleCopy = useCallback(() => {
     navigator.clipboard.writeText(jsonString)
     setCopied(true)
-      if (copyTimerRef.current !== null) window.clearTimeout(copyTimerRef.current)
+    setTimeout(() => setCopied(false), 1500)
-      copyTimerRef.current = window.setTimeout(() => setCopied(false), 1500)
     closeContextMenu()
   }, [jsonString, closeContextMenu])
 
-    useEffect(() => {
-      return () => {
-        if (copyTimerRef.current !== null) window.clearTimeout(copyTimerRef.current)
-      }
-    }, [])
-
   const handleSearch = useCallback(() => {
     activateSearch()
     closeContextMenu()
@@ -193,12 +185,7 @@ const WorkflowOutputSection = memo(
           >
             <ArrowDown className='h-[12px] w-[12px]' />
           </Button>
-            <Button
+          <Button variant='ghost' className='!p-1' onClick={closeSearch} aria-label='Close search'>
-              variant='ghost'
-              className='!p-1'
-              onClick={closeSearch}
-              aria-label='Close search'
-            >
             <X className='h-[12px] w-[12px]' />
           </Button>
         </div>
@@ -233,9 +220,7 @@ const WorkflowOutputSection = memo(
         )}
     </div>
   )
-  },
+}
-  (prev, next) => prev.output === next.output
-)
 
 interface LogDetailsProps {
   /** The log to display details for */
@@ -293,6 +278,7 @@ export const LogDetails = memo(function LogDetails({
     return isWorkflowExecutionLog && log?.cost
   }, [log, isWorkflowExecutionLog])
 
+  // Extract and clean the workflow final output (recursively remove hidden keys for cleaner display)
   const workflowOutput = useMemo(() => {
     const executionData = log?.executionData as
       | { finalOutput?: Record<string, unknown> }

apps/sim/app/workspace/[workspaceId]/logs/components/log-row-context-menu/log-row-context-menu.tsx

@@ -1,7 +1,6 @@
 'use client'
 
 import type { RefObject } from 'react'
-import { memo } from 'react'
 import {
   Popover,
   PopoverAnchor,
@@ -30,7 +29,7 @@ interface LogRowContextMenuProps {
  * Context menu for log rows.
  * Provides quick actions for copying data, navigation, and filtering.
  */
-export const LogRowContextMenu = memo(function LogRowContextMenu({
+export function LogRowContextMenu({
   isOpen,
   position,
   menuRef,
@@ -122,4 +121,4 @@ export const LogRowContextMenu = memo(function LogRowContextMenu({
       </PopoverContent>
     </Popover>
   )
-})
+}

apps/sim/app/workspace/[workspaceId]/logs/components/logs-list/logs-list.tsx

@@ -24,7 +24,6 @@ interface LogRowProps {
   log: WorkflowLog
   isSelected: boolean
   onClick: (log: WorkflowLog) => void
-  onHover?: (log: WorkflowLog) => void
   onContextMenu?: (e: React.MouseEvent, log: WorkflowLog) => void
   selectedRowRef: React.RefObject<HTMLTableRowElement | null> | null
 }
@@ -34,14 +33,7 @@ interface LogRowProps {
  * Uses shallow comparison for the log object.
  */
 const LogRow = memo(
-  function LogRow({
+  function LogRow({ log, isSelected, onClick, onContextMenu, selectedRowRef }: LogRowProps) {
-    log,
-    isSelected,
-    onClick,
-    onHover,
-    onContextMenu,
-    selectedRowRef,
-  }: LogRowProps) {
     const formattedDate = useMemo(() => formatDate(log.createdAt), [log.createdAt])
     const isDeletedWorkflow = !log.workflow?.id && !log.workflowId
     const workflowName = isDeletedWorkflow
@@ -51,8 +43,6 @@ const LogRow = memo(
 
     const handleClick = useCallback(() => onClick(log), [onClick, log])
 
-    const handleMouseEnter = useCallback(() => onHover?.(log), [onHover, log])
-
     const handleContextMenu = useCallback(
       (e: React.MouseEvent) => {
         if (onContextMenu) {
@@ -71,7 +61,6 @@ const LogRow = memo(
           isSelected && 'bg-[var(--surface-3)] dark:bg-[var(--surface-4)]'
         )}
         onClick={handleClick}
-        onMouseEnter={handleMouseEnter}
         onContextMenu={handleContextMenu}
       >
         <div className='flex flex-1 items-center'>
@@ -153,8 +142,7 @@ const LogRow = memo(
       prevProps.log.id === nextProps.log.id &&
       prevProps.log.duration === nextProps.log.duration &&
       prevProps.log.status === nextProps.log.status &&
-      prevProps.isSelected === nextProps.isSelected &&
+      prevProps.isSelected === nextProps.isSelected
-      prevProps.onHover === nextProps.onHover
     )
   }
 )
@@ -163,7 +151,6 @@ interface RowProps {
   logs: WorkflowLog[]
   selectedLogId: string | null
   onLogClick: (log: WorkflowLog) => void
-  onLogHover?: (log: WorkflowLog) => void
   onLogContextMenu?: (e: React.MouseEvent, log: WorkflowLog) => void
   selectedRowRef: React.RefObject<HTMLTableRowElement | null>
   isFetchingNextPage: boolean
@@ -180,7 +167,6 @@ function Row({
   logs,
   selectedLogId,
   onLogClick,
-  onLogHover,
   onLogContextMenu,
   selectedRowRef,
   isFetchingNextPage,
@@ -212,7 +198,6 @@ function Row({
         log={log}
         isSelected={isSelected}
         onClick={onLogClick}
-        onHover={onLogHover}
         onContextMenu={onLogContextMenu}
         selectedRowRef={isSelected ? selectedRowRef : null}
       />
@@ -224,7 +209,6 @@ export interface LogsListProps {
   logs: WorkflowLog[]
   selectedLogId: string | null
   onLogClick: (log: WorkflowLog) => void
-  onLogHover?: (log: WorkflowLog) => void
   onLogContextMenu?: (e: React.MouseEvent, log: WorkflowLog) => void
   selectedRowRef: React.RefObject<HTMLTableRowElement | null>
   hasNextPage: boolean
@@ -243,7 +227,6 @@ export function LogsList({
   logs,
   selectedLogId,
   onLogClick,
-  onLogHover,
   onLogContextMenu,
   selectedRowRef,
   hasNextPage,
@@ -289,7 +272,6 @@ export function LogsList({
       logs,
       selectedLogId,
       onLogClick,
-      onLogHover,
       onLogContextMenu,
       selectedRowRef,
       isFetchingNextPage,
@@ -299,7 +281,6 @@ export function LogsList({
       logs,
       selectedLogId,
       onLogClick,
-      onLogHover,
       onLogContextMenu,
       selectedRowRef,
       isFetchingNextPage,

apps/sim/app/workspace/[workspaceId]/logs/components/logs-toolbar/components/notifications/notifications.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { memo, useCallback, useEffect, useMemo, useState } from 'react'
+import { useCallback, useEffect, useMemo, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import { Plus, X } from 'lucide-react'
 import {
@@ -113,7 +113,7 @@ function formatAlertConfigLabel(config: {
   }
 }
 
-export const NotificationSettings = memo(function NotificationSettings({
+export function NotificationSettings({
   workspaceId,
   open,
   onOpenChange,
@@ -144,7 +144,7 @@ export const NotificationSettings = memo(function NotificationSettings({
     slackChannelId: '',
     slackChannelName: '',
     slackAccountId: '',
-
+    useAlertRule: false,
     alertRule: 'none' as AlertRule,
     consecutiveFailures: 3,
     failureRatePercent: 50,
@@ -212,7 +212,7 @@ export const NotificationSettings = memo(function NotificationSettings({
       slackChannelId: '',
       slackChannelName: '',
       slackAccountId: '',
-
+      useAlertRule: false,
       alertRule: 'none',
       consecutiveFailures: 3,
       failureRatePercent: 50,
@@ -484,6 +484,7 @@ export const NotificationSettings = memo(function NotificationSettings({
       slackChannelId: subscription.slackConfig?.channelId || '',
       slackChannelName: subscription.slackConfig?.channelName || '',
       slackAccountId: subscription.slackConfig?.accountId || '',
+      useAlertRule: !!subscription.alertConfig,
       alertRule: subscription.alertConfig?.rule || 'none',
       consecutiveFailures: subscription.alertConfig?.consecutiveFailures || 3,
       failureRatePercent: subscription.alertConfig?.failureRatePercent || 50,
@@ -1288,4 +1289,4 @@ export const NotificationSettings = memo(function NotificationSettings({
       </Modal>
     </>
   )
-})
+}

apps/sim/app/workspace/[workspaceId]/logs/components/logs-toolbar/logs-toolbar.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { memo, useCallback, useMemo, useState } from 'react'
+import { useCallback, useMemo, useState } from 'react'
 import { ArrowUp, Bell, Library, MoreHorizontal, RefreshCw } from 'lucide-react'
 import { useParams } from 'next/navigation'
 import {
@@ -149,7 +149,7 @@ function getTriggerIcon(
  * @param props - The component props
  * @returns The complete logs toolbar
  */
-export const LogsToolbar = memo(function LogsToolbar({
+export function LogsToolbar({
   viewMode,
   onViewModeChange,
   isRefreshing,
@@ -749,4 +749,4 @@ export const LogsToolbar = memo(function LogsToolbar({
       </div>
     </div>
   )
-})
+}

apps/sim/app/workspace/[workspaceId]/logs/logs.tsx

@@ -1,7 +1,6 @@
 'use client'
 
-import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { useQueryClient } from '@tanstack/react-query'
 import { Loader2 } from 'lucide-react'
 import { useParams } from 'next/navigation'
 import { cn } from '@/lib/core/utils/cn'
@@ -11,17 +10,12 @@ import {
   hasActiveFilters,
 } from '@/lib/logs/filters'
 import { parseQuery, queryToApiParams } from '@/lib/logs/query-parser'
-import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import { useFolders } from '@/hooks/queries/folders'
-import {
+import { useDashboardStats, useLogDetail, useLogsList } from '@/hooks/queries/logs'
-  prefetchLogDetail,
-  useDashboardStats,
-  useLogDetail,
-  useLogsList,
-} from '@/hooks/queries/logs'
 import { useDebounce } from '@/hooks/use-debounce'
 import { useFilterStore } from '@/stores/logs/filters/store'
 import type { WorkflowLog } from '@/stores/logs/filters/types'
+import { useUserPermissionsContext } from '../providers/workspace-permissions-provider'
 import {
   Dashboard,
   ExecutionSnapshot,
@@ -36,38 +30,6 @@ import { LOG_COLUMN_ORDER, LOG_COLUMNS } from './utils'
 const LOGS_PER_PAGE = 50 as const
 const REFRESH_SPINNER_DURATION_MS = 1000 as const
 
-interface LogSelectionState {
-  selectedLogId: string | null
-  isSidebarOpen: boolean
-}
-
-type LogSelectionAction =
-  | { type: 'TOGGLE_LOG'; logId: string }
-  | { type: 'SELECT_LOG'; logId: string }
-  | { type: 'CLOSE_SIDEBAR' }
-  | { type: 'TOGGLE_SIDEBAR' }
-
-function logSelectionReducer(
-  state: LogSelectionState,
-  action: LogSelectionAction
-): LogSelectionState {
-  switch (action.type) {
-    case 'TOGGLE_LOG':
-      if (state.selectedLogId === action.logId && state.isSidebarOpen) {
-        return { selectedLogId: null, isSidebarOpen: false }
-      }
-      return { selectedLogId: action.logId, isSidebarOpen: true }
-    case 'SELECT_LOG':
-      return { ...state, selectedLogId: action.logId }
-    case 'CLOSE_SIDEBAR':
-      return { selectedLogId: null, isSidebarOpen: false }
-    case 'TOGGLE_SIDEBAR':
-      return state.selectedLogId ? { ...state, isSidebarOpen: !state.isSidebarOpen } : state
-    default:
-      return state
-  }
-}
-
 /**
  * Logs page component displaying workflow execution history.
  * Supports filtering, search, live updates, and detailed log inspection.
@@ -98,13 +60,11 @@ export default function Logs() {
     setWorkspaceId(workspaceId)
   }, [workspaceId, setWorkspaceId])
 
-  const [{ selectedLogId, isSidebarOpen }, dispatch] = useReducer(logSelectionReducer, {
+  const [selectedLogId, setSelectedLogId] = useState<string | null>(null)
-    selectedLogId: null,
+  const [isSidebarOpen, setIsSidebarOpen] = useState(false)
-    isSidebarOpen: false,
-  })
   const selectedRowRef = useRef<HTMLTableRowElement | null>(null)
   const loaderRef = useRef<HTMLDivElement>(null)
-
+  const scrollContainerRef = useRef<HTMLDivElement>(null)
   const isInitialized = useRef<boolean>(false)
 
   const [searchQuery, setSearchQuery] = useState('')
@@ -122,13 +82,6 @@ export default function Logs() {
   const [isVisuallyRefreshing, setIsVisuallyRefreshing] = useState(false)
   const [isExporting, setIsExporting] = useState(false)
   const isSearchOpenRef = useRef<boolean>(false)
-  const refreshTimersRef = useRef(new Set<number>())
-  const logsRef = useRef<WorkflowLog[]>([])
-  const selectedLogIndexRef = useRef(-1)
-  const selectedLogIdRef = useRef<string | null>(null)
-  const logsRefetchRef = useRef<() => void>(() => {})
-  const activeLogRefetchRef = useRef<() => void>(() => {})
-  const logsQueryRef = useRef({ isFetching: false, hasNextPage: false, fetchNextPage: () => {} })
   const [isNotificationSettingsOpen, setIsNotificationSettingsOpen] = useState(false)
   const userPermissions = useUserPermissionsContext()
 
@@ -141,19 +94,8 @@ export default function Logs() {
   const [previewLogId, setPreviewLogId] = useState<string | null>(null)
 
   const activeLogId = isPreviewOpen ? previewLogId : selectedLogId
-  const queryClient = useQueryClient()
-
-  const detailRefetchInterval = useCallback(
-    (query: { state: { data?: WorkflowLog } }) => {
-      if (!isLive) return false
-      const status = query.state.data?.status
-      return status === 'running' || status === 'pending' ? 3000 : false
-    },
-    [isLive]
-  )
-
   const activeLogQuery = useLogDetail(activeLogId ?? undefined, {
-    refetchInterval: detailRefetchInterval,
+    refetchInterval: isLive ? 3000 : false,
   })
 
   const logFilters = useMemo(
@@ -212,73 +154,42 @@ export default function Logs() {
     return { ...selectedLogFromList, ...activeLogQuery.data }
   }, [selectedLogFromList, activeLogQuery.data, isPreviewOpen])
 
-  const handleLogHover = useCallback(
-    (log: WorkflowLog) => {
-      prefetchLogDetail(queryClient, log.id)
-    },
-    [queryClient]
-  )
-
   useFolders(workspaceId)
 
-  useEffect(() => {
-    logsRef.current = logs
-  }, [logs])
-  useEffect(() => {
-    selectedLogIndexRef.current = selectedLogIndex
-  }, [selectedLogIndex])
-  useEffect(() => {
-    selectedLogIdRef.current = selectedLogId
-  }, [selectedLogId])
-  useEffect(() => {
-    logsRefetchRef.current = logsQuery.refetch
-  }, [logsQuery.refetch])
-  useEffect(() => {
-    activeLogRefetchRef.current = activeLogQuery.refetch
-  }, [activeLogQuery.refetch])
-  useEffect(() => {
-    logsQueryRef.current = {
-      isFetching: logsQuery.isFetching,
-      hasNextPage: logsQuery.hasNextPage ?? false,
-      fetchNextPage: logsQuery.fetchNextPage,
-    }
-  }, [logsQuery.isFetching, logsQuery.hasNextPage, logsQuery.fetchNextPage])
-
-  useEffect(() => {
-    const timers = refreshTimersRef.current
-    return () => {
-      timers.forEach((id) => window.clearTimeout(id))
-      timers.clear()
-    }
-  }, [])
-
   useEffect(() => {
     if (isInitialized.current) {
       setStoreSearchQuery(debouncedSearchQuery)
     }
   }, [debouncedSearchQuery, setStoreSearchQuery])
 
-  const handleLogClick = useCallback((log: WorkflowLog) => {
+  const handleLogClick = useCallback(
-    dispatch({ type: 'TOGGLE_LOG', logId: log.id })
+    (log: WorkflowLog) => {
-  }, [])
+      if (selectedLogId === log.id && isSidebarOpen) {
+        setIsSidebarOpen(false)
+        setSelectedLogId(null)
+        return
+      }
+      setSelectedLogId(log.id)
+      setIsSidebarOpen(true)
+    },
+    [selectedLogId, isSidebarOpen]
+  )
 
   const handleNavigateNext = useCallback(() => {
-    const idx = selectedLogIndexRef.current
+    if (selectedLogIndex < logs.length - 1) {
-    const currentLogs = logsRef.current
+      setSelectedLogId(logs[selectedLogIndex + 1].id)
-    if (idx < currentLogs.length - 1) {
-      dispatch({ type: 'SELECT_LOG', logId: currentLogs[idx + 1].id })
     }
-  }, [])
+  }, [selectedLogIndex, logs])
 
   const handleNavigatePrev = useCallback(() => {
-    const idx = selectedLogIndexRef.current
+    if (selectedLogIndex > 0) {
-    if (idx > 0) {
+      setSelectedLogId(logs[selectedLogIndex - 1].id)
-      dispatch({ type: 'SELECT_LOG', logId: logsRef.current[idx - 1].id })
     }
-  }, [])
+  }, [selectedLogIndex, logs])
 
   const handleCloseSidebar = useCallback(() => {
-    dispatch({ type: 'CLOSE_SIDEBAR' })
+    setIsSidebarOpen(false)
+    setSelectedLogId(null)
   }, [])
 
   const handleLogContextMenu = useCallback((e: React.MouseEvent, log: WorkflowLog) => {
@@ -349,34 +260,26 @@ export default function Logs() {
 
   const handleRefresh = useCallback(() => {
     setIsVisuallyRefreshing(true)
-    const timerId = window.setTimeout(() => {
+    setTimeout(() => setIsVisuallyRefreshing(false), REFRESH_SPINNER_DURATION_MS)
-      setIsVisuallyRefreshing(false)
+    logsQuery.refetch()
-      refreshTimersRef.current.delete(timerId)
+    if (selectedLogId) {
-    }, REFRESH_SPINNER_DURATION_MS)
+      activeLogQuery.refetch()
-    refreshTimersRef.current.add(timerId)
-    logsRefetchRef.current()
-    if (selectedLogIdRef.current) {
-      activeLogRefetchRef.current()
     }
-  }, [])
+  }, [logsQuery, activeLogQuery, selectedLogId])
 
   const handleToggleLive = useCallback(() => {
-    setIsLive((prev) => {
+    const newIsLive = !isLive
-      if (!prev) {
+    setIsLive(newIsLive)
+
+    if (newIsLive) {
       setIsVisuallyRefreshing(true)
-        const timerId = window.setTimeout(() => {
+      setTimeout(() => setIsVisuallyRefreshing(false), REFRESH_SPINNER_DURATION_MS)
-          setIsVisuallyRefreshing(false)
+      logsQuery.refetch()
-          refreshTimersRef.current.delete(timerId)
+      if (selectedLogId) {
-        }, REFRESH_SPINNER_DURATION_MS)
+        activeLogQuery.refetch()
-        refreshTimersRef.current.add(timerId)
-        logsRefetchRef.current()
-        if (selectedLogIdRef.current) {
-          activeLogRefetchRef.current()
       }
     }
-      return !prev
+  }, [isLive, logsQuery, activeLogQuery, selectedLogId])
-    })
-  }, [])
 
   const prevIsFetchingRef = useRef(logsQuery.isFetching)
   useEffect(() => {
@@ -386,15 +289,11 @@ export default function Logs() {
 
     if (isLive && !wasFetching && isFetching) {
       setIsVisuallyRefreshing(true)
-      const timerId = window.setTimeout(() => {
+      setTimeout(() => setIsVisuallyRefreshing(false), REFRESH_SPINNER_DURATION_MS)
-        setIsVisuallyRefreshing(false)
-        refreshTimersRef.current.delete(timerId)
-      }, REFRESH_SPINNER_DURATION_MS)
-      refreshTimersRef.current.add(timerId)
     }
   }, [logsQuery.isFetching, isLive])
 
-  const handleExport = useCallback(async () => {
+  const handleExport = async () => {
     setIsExporting(true)
     try {
       const params = new URLSearchParams()
@@ -428,17 +327,7 @@ export default function Logs() {
     } finally {
       setIsExporting(false)
     }
-  }, [
+  }
-    workspaceId,
-    level,
-    triggers,
-    workflowIds,
-    folderIds,
-    timeRange,
-    startDate,
-    endDate,
-    debouncedSearchQuery,
-  ])
 
   useEffect(() => {
     if (!isInitialized.current) {
@@ -459,59 +348,41 @@ export default function Logs() {
   }, [initializeFromURL])
 
   const loadMoreLogs = useCallback(() => {
-    const { isFetching, hasNextPage, fetchNextPage } = logsQueryRef.current
+    if (!logsQuery.isFetching && logsQuery.hasNextPage) {
-    if (!isFetching && hasNextPage) {
+      logsQuery.fetchNextPage()
-      fetchNextPage()
     }
-  }, [])
+  }, [logsQuery])
 
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
       if (isSearchOpenRef.current) return
-      const currentLogs = logsRef.current
+      if (logs.length === 0) return
-      const currentIndex = selectedLogIndexRef.current
-      if (currentLogs.length === 0) return
 
-      if (currentIndex === -1 && (e.key === 'ArrowUp' || e.key === 'ArrowDown')) {
+      if (selectedLogIndex === -1 && (e.key === 'ArrowUp' || e.key === 'ArrowDown')) {
         e.preventDefault()
-        dispatch({ type: 'SELECT_LOG', logId: currentLogs[0].id })
+        setSelectedLogId(logs[0].id)
         return
       }
 
-      if (e.key === 'ArrowUp' && !e.metaKey && !e.ctrlKey && currentIndex > 0) {
+      if (e.key === 'ArrowUp' && !e.metaKey && !e.ctrlKey && selectedLogIndex > 0) {
         e.preventDefault()
         handleNavigatePrev()
       }
 
-      if (
+      if (e.key === 'ArrowDown' && !e.metaKey && !e.ctrlKey && selectedLogIndex < logs.length - 1) {
-        e.key === 'ArrowDown' &&
-        !e.metaKey &&
-        !e.ctrlKey &&
-        currentIndex < currentLogs.length - 1
-      ) {
         e.preventDefault()
         handleNavigateNext()
       }
 
-      if (e.key === 'Enter' && selectedLogIdRef.current) {
+      if (e.key === 'Enter' && selectedLogId) {
         e.preventDefault()
-        dispatch({ type: 'TOGGLE_SIDEBAR' })
+        setIsSidebarOpen(!isSidebarOpen)
       }
     }
 
     window.addEventListener('keydown', handleKeyDown)
     return () => window.removeEventListener('keydown', handleKeyDown)
-  }, [handleNavigateNext, handleNavigatePrev])
+  }, [logs, selectedLogIndex, isSidebarOpen, selectedLogId, handleNavigateNext, handleNavigatePrev])
-
-  const handleCloseContextMenu = useCallback(() => setContextMenuOpen(false), [])
-  const handleOpenNotificationSettings = useCallback(() => setIsNotificationSettingsOpen(true), [])
-  const handleSearchOpenChange = useCallback((open: boolean) => {
-    isSearchOpenRef.current = open
-  }, [])
-  const handleClosePreview = useCallback(() => {
-    setIsPreviewOpen(false)
-    setPreviewLogId(null)
-  }, [])
 
   const isDashboardView = viewMode === 'dashboard'
 
@@ -531,10 +402,12 @@ export default function Logs() {
               onExport={handleExport}
               canEdit={userPermissions.canEdit}
               hasLogs={logs.length > 0}
-              onOpenNotificationSettings={handleOpenNotificationSettings}
+              onOpenNotificationSettings={() => setIsNotificationSettingsOpen(true)}
               searchQuery={searchQuery}
               onSearchQueryChange={setSearchQuery}
-              onSearchOpenChange={handleSearchOpenChange}
+              onSearchOpenChange={(open: boolean) => {
+                isSearchOpenRef.current = open
+              }}
             />
           </div>
 
@@ -576,7 +449,7 @@ export default function Logs() {
               </div>
 
               {/* Table body - virtualized */}
-              <div className='min-h-0 flex-1 overflow-hidden'>
+              <div className='min-h-0 flex-1 overflow-hidden' ref={scrollContainerRef}>
                 {logsQuery.isLoading && !logsQuery.data ? (
                   <div className='flex h-full items-center justify-center'>
                     <div className='flex items-center gap-[8px] text-[var(--text-secondary)]'>
@@ -603,7 +476,6 @@ export default function Logs() {
                     logs={logs}
                     selectedLogId={selectedLogId}
                     onLogClick={handleLogClick}
-                    onLogHover={handleLogHover}
                     onLogContextMenu={handleLogContextMenu}
                     selectedRowRef={selectedRowRef}
                     hasNextPage={logsQuery.hasNextPage ?? false}
@@ -639,7 +511,7 @@ export default function Logs() {
         isOpen={contextMenuOpen}
         position={contextMenuPosition}
         menuRef={contextMenuRef}
-        onClose={handleCloseContextMenu}
+        onClose={() => setContextMenuOpen(false)}
         log={contextMenuLog}
         onCopyExecutionId={handleCopyExecutionId}
         onOpenWorkflow={handleOpenWorkflow}
@@ -656,7 +528,10 @@ export default function Logs() {
           traceSpans={activeLogQuery.data.executionData?.traceSpans}
           isModal
           isOpen={isPreviewOpen}
-          onClose={handleClosePreview}
+          onClose={() => {
+            setIsPreviewOpen(false)
+            setPreviewLogId(null)
+          }}
         />
       )}
     </div>

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +1,7 @@
 import { useCallback, useState } from 'react'
 import { createLogger } from '@sim/logger'
-import { runPreDeployChecks } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/deploy/hooks/use-predeploy-checks'
 import { useNotificationStore } from '@/stores/notifications'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
-import { mergeSubblockState } from '@/stores/workflows/utils'
-import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 const logger = createLogger('useDeployment')
 
@@ -38,24 +35,6 @@ export function useDeployment({
       return { success: true, shouldOpenModal: true }
     }
 
-    const { blocks, edges, loops, parallels } = useWorkflowStore.getState()
-    const liveBlocks = mergeSubblockState(blocks, workflowId)
-    const checkResult = runPreDeployChecks({
-      blocks: liveBlocks,
-      edges,
-      loops,
-      parallels,
-      workflowId,
-    })
-    if (!checkResult.passed) {
-      addNotification({
-        level: 'error',
-        message: checkResult.error || 'Pre-deploy validation failed',
-        workflowId,
-      })
-      return { success: false, shouldOpenModal: false }
-    }
-
     setIsDeploying(true)
     try {
       const response = await fetch(`/api/workflows/${workflowId}/deploy`, {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/combobox/combobox.tsx

@@ -239,13 +239,8 @@ export const ComboBox = memo(function ComboBox({
    */
   const defaultOptionValue = useMemo(() => {
     if (defaultValue !== undefined) {
-      // Validate that the default value exists in the available (filtered) options
-      const defaultInOptions = evaluatedOptions.find((opt) => getOptionValue(opt) === defaultValue)
-      if (defaultInOptions) {
       return defaultValue
     }
-      // Default not available (e.g. provider disabled) — fall through to other fallbacks
-    }
 
     // For model field, default to claude-sonnet-4-5 if available
     if (subBlockId === 'model') {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/components/tool-credential-selector.tsx

@@ -4,7 +4,6 @@ import { Button, Combobox } from '@/components/emcn/components'
 import {
   getCanonicalScopesForProvider,
   getProviderIdFromServiceId,
-  getServiceConfigByProviderId,
   OAUTH_PROVIDERS,
   type OAuthProvider,
   type OAuthService,
@@ -27,11 +26,6 @@ const getProviderIcon = (providerName: OAuthProvider) => {
 }
 
 const getProviderName = (providerName: OAuthProvider) => {
-  const serviceConfig = getServiceConfigByProviderId(providerName)
-  if (serviceConfig) {
-    return serviceConfig.name
-  }
-
   const { baseProvider } = parseProvider(providerName)
   const baseProviderConfig = OAUTH_PROVIDERS[baseProvider]
 
@@ -60,7 +54,7 @@ export function ToolCredentialSelector({
   onChange,
   provider,
   requiredScopes = [],
-  label,
+  label = 'Select account',
   serviceId,
   disabled = false,
 }: ToolCredentialSelectorProps) {
@@ -70,7 +64,6 @@ export function ToolCredentialSelector({
   const { activeWorkflowId } = useWorkflowRegistry()
 
   const selectedId = value || ''
-  const effectiveLabel = label || `Select ${getProviderName(provider)} account`
 
   const effectiveProviderId = useMemo(() => getProviderIdFromServiceId(serviceId), [serviceId])
 
@@ -210,7 +203,7 @@ export function ToolCredentialSelector({
         selectedValue={selectedId}
         onChange={handleComboboxChange}
         onOpenChange={handleOpenChange}
-        placeholder={effectiveLabel}
+        placeholder={label}
         disabled={disabled}
         editable={true}
         filterOptions={!isForeign}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/components/tools/parameter.tsx

@@ -1,186 +0,0 @@
-'use client'
-
-import type React from 'react'
-import { useRef, useState } from 'react'
-import { ArrowLeftRight, ArrowUp } from 'lucide-react'
-import { Button, Input, Label, Tooltip } from '@/components/emcn'
-import { cn } from '@/lib/core/utils/cn'
-import type { WandControlHandlers } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block'
-
-/**
- * Props for a generic parameter with label component
- */
-export interface ParameterWithLabelProps {
-  paramId: string
-  title: string
-  isRequired: boolean
-  visibility: string
-  wandConfig?: {
-    enabled: boolean
-    prompt?: string
-    placeholder?: string
-  }
-  canonicalToggle?: {
-    mode: 'basic' | 'advanced'
-    disabled?: boolean
-    onToggle?: () => void
-  }
-  disabled: boolean
-  isPreview: boolean
-  children: (wandControlRef: React.MutableRefObject<WandControlHandlers | null>) => React.ReactNode
-}
-
-/**
- * Generic wrapper component for parameters that manages wand state and renders label + input
- */
-export function ParameterWithLabel({
-  paramId,
-  title,
-  isRequired,
-  visibility,
-  wandConfig,
-  canonicalToggle,
-  disabled,
-  isPreview,
-  children,
-}: ParameterWithLabelProps) {
-  const [isSearchActive, setIsSearchActive] = useState(false)
-  const [searchQuery, setSearchQuery] = useState('')
-  const searchInputRef = useRef<HTMLInputElement>(null)
-  const wandControlRef = useRef<WandControlHandlers | null>(null)
-
-  const isWandEnabled = wandConfig?.enabled ?? false
-  const showWand = isWandEnabled && !isPreview && !disabled
-
-  const handleSearchClick = (): void => {
-    setIsSearchActive(true)
-    setTimeout(() => {
-      searchInputRef.current?.focus()
-    }, 0)
-  }
-
-  const handleSearchBlur = (): void => {
-    if (!searchQuery.trim() && !wandControlRef.current?.isWandStreaming) {
-      setIsSearchActive(false)
-    }
-  }
-
-  const handleSearchChange = (value: string): void => {
-    setSearchQuery(value)
-  }
-
-  const handleSearchSubmit = (): void => {
-    if (searchQuery.trim() && wandControlRef.current) {
-      wandControlRef.current.onWandTrigger(searchQuery)
-      setSearchQuery('')
-      setIsSearchActive(false)
-    }
-  }
-
-  const handleSearchCancel = (): void => {
-    setSearchQuery('')
-    setIsSearchActive(false)
-  }
-
-  const isStreaming = wandControlRef.current?.isWandStreaming ?? false
-
-  return (
-    <div key={paramId} className='relative min-w-0 space-y-[6px]'>
-      <div className='flex items-center justify-between gap-[6px] pl-[2px]'>
-        <Label className='flex items-baseline gap-[6px] whitespace-nowrap font-medium text-[13px] text-[var(--text-primary)]'>
-          {title}
-          {isRequired && visibility === 'user-only' && <span className='ml-0.5'>*</span>}
-        </Label>
-        <div className='flex min-w-0 flex-1 items-center justify-end gap-[6px]'>
-          {showWand &&
-            (!isSearchActive ? (
-              <Button
-                variant='active'
-                className='-my-1 h-5 px-2 py-0 text-[11px]'
-                onClick={handleSearchClick}
-              >
-                Generate
-              </Button>
-            ) : (
-              <div className='-my-1 flex min-w-[120px] max-w-[280px] flex-1 items-center gap-[4px]'>
-                <Input
-                  ref={searchInputRef}
-                  value={isStreaming ? 'Generating...' : searchQuery}
-                  onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
-                    handleSearchChange(e.target.value)
-                  }
-                  onBlur={(e: React.FocusEvent<HTMLInputElement>) => {
-                    const relatedTarget = e.relatedTarget as HTMLElement | null
-                    if (relatedTarget?.closest('button')) return
-                    handleSearchBlur()
-                  }}
-                  onKeyDown={(e: React.KeyboardEvent<HTMLInputElement>) => {
-                    if (e.key === 'Enter' && searchQuery.trim() && !isStreaming) {
-                      handleSearchSubmit()
-                    } else if (e.key === 'Escape') {
-                      handleSearchCancel()
-                    }
-                  }}
-                  disabled={isStreaming}
-                  className={cn(
-                    'h-5 min-w-[80px] flex-1 text-[11px]',
-                    isStreaming && 'text-muted-foreground'
-                  )}
-                  placeholder='Generate with AI...'
-                />
-                <Button
-                  variant='tertiary'
-                  disabled={!searchQuery.trim() || isStreaming}
-                  onMouseDown={(e: React.MouseEvent) => {
-                    e.preventDefault()
-                    e.stopPropagation()
-                  }}
-                  onClick={(e: React.MouseEvent) => {
-                    e.stopPropagation()
-                    handleSearchSubmit()
-                  }}
-                  className='h-[20px] w-[20px] flex-shrink-0 p-0'
-                >
-                  <ArrowUp className='h-[12px] w-[12px]' />
-                </Button>
-              </div>
-            ))}
-          {canonicalToggle && !isPreview && (
-            <Tooltip.Root>
-              <Tooltip.Trigger asChild>
-                <button
-                  type='button'
-                  className='flex h-[12px] w-[12px] flex-shrink-0 items-center justify-center bg-transparent p-0 disabled:cursor-not-allowed disabled:opacity-50'
-                  onClick={canonicalToggle.onToggle}
-                  disabled={canonicalToggle.disabled || disabled}
-                  aria-label={
-                    canonicalToggle.mode === 'advanced'
-                      ? 'Switch to selector'
-                      : 'Switch to manual ID'
-                  }
-                >
-                  <ArrowLeftRight
-                    className={cn(
-                      '!h-[12px] !w-[12px]',
-                      canonicalToggle.mode === 'advanced'
-                        ? 'text-[var(--text-primary)]'
-                        : 'text-[var(--text-secondary)]'
-                    )}
-                  />
-                </button>
-              </Tooltip.Trigger>
-              <Tooltip.Content side='top'>
-                <p>
-                  {canonicalToggle.mode === 'advanced'
-                    ? 'Switch to selector'
-                    : 'Switch to manual ID'}
-                </p>
-              </Tooltip.Content>
-            </Tooltip.Root>
-          )}
-        </div>
-      </div>
-      <div className='relative w-full min-w-0'>{children(wandControlRef)}</div>
-    </div>
-  )
-}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/components/tools/sub-block-renderer.tsx

@@ -1,114 +0,0 @@
-'use client'
-
-import { useEffect, useRef } from 'react'
-import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-value'
-import { SubBlock } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block'
-import type { SubBlockConfig as BlockSubBlockConfig } from '@/blocks/types'
-
-interface ToolSubBlockRendererProps {
-  blockId: string
-  subBlockId: string
-  toolIndex: number
-  subBlock: BlockSubBlockConfig
-  effectiveParamId: string
-  toolParams: Record<string, string> | undefined
-  onParamChange: (toolIndex: number, paramId: string, value: string) => void
-  disabled: boolean
-  canonicalToggle?: {
-    mode: 'basic' | 'advanced'
-    disabled?: boolean
-    onToggle?: () => void
-  }
-}
-
-/**
- * SubBlock types whose store values are objects/arrays/non-strings.
- * tool.params stores strings (via JSON.stringify), so when syncing
- * back to the store we parse them to restore the native shape.
- */
-const OBJECT_SUBBLOCK_TYPES = new Set(['file-upload', 'table', 'grouped-checkbox-list'])
-
-/**
- * Bridges the subblock store with StoredTool.params via a synthetic store key,
- * then delegates all rendering to SubBlock for full parity.
- */
-export function ToolSubBlockRenderer({
-  blockId,
-  subBlockId,
-  toolIndex,
-  subBlock,
-  effectiveParamId,
-  toolParams,
-  onParamChange,
-  disabled,
-  canonicalToggle,
-}: ToolSubBlockRendererProps) {
-  const syntheticId = `${subBlockId}-tool-${toolIndex}-${effectiveParamId}`
-  const [storeValue, setStoreValue] = useSubBlockValue(blockId, syntheticId)
-
-  const toolParamValue = toolParams?.[effectiveParamId] ?? ''
-  const isObjectType = OBJECT_SUBBLOCK_TYPES.has(subBlock.type)
-
-  const lastPushedToStoreRef = useRef<string | null>(null)
-  const lastPushedToParamsRef = useRef<string | null>(null)
-
-  useEffect(() => {
-    if (!toolParamValue && lastPushedToStoreRef.current === null) {
-      lastPushedToStoreRef.current = toolParamValue
-      lastPushedToParamsRef.current = toolParamValue
-      return
-    }
-    if (toolParamValue !== lastPushedToStoreRef.current) {
-      lastPushedToStoreRef.current = toolParamValue
-      lastPushedToParamsRef.current = toolParamValue
-
-      if (isObjectType && typeof toolParamValue === 'string' && toolParamValue) {
-        try {
-          const parsed = JSON.parse(toolParamValue)
-          if (typeof parsed === 'object' && parsed !== null) {
-            setStoreValue(parsed)
-            return
-          }
-        } catch {
-          // Not valid JSON — fall through to set as string
-        }
-      }
-      setStoreValue(toolParamValue)
-    }
-  }, [toolParamValue, setStoreValue, isObjectType])
-
-  useEffect(() => {
-    if (storeValue == null && lastPushedToParamsRef.current === null) return
-    const stringValue =
-      storeValue == null
-        ? ''
-        : typeof storeValue === 'string'
-          ? storeValue
-          : JSON.stringify(storeValue)
-    if (stringValue !== lastPushedToParamsRef.current) {
-      lastPushedToParamsRef.current = stringValue
-      lastPushedToStoreRef.current = stringValue
-      onParamChange(toolIndex, effectiveParamId, stringValue)
-    }
-  }, [storeValue, toolIndex, effectiveParamId, onParamChange])
-
-  const visibility = subBlock.paramVisibility ?? 'user-or-llm'
-  const isOptionalForUser = visibility !== 'user-only'
-
-  const config = {
-    ...subBlock,
-    id: syntheticId,
-    ...(isOptionalForUser && { required: false }),
-  }
-
-  return (
-    <SubBlock
-      blockId={blockId}
-      config={config}
-      isPreview={false}
-      disabled={disabled}
-      canonicalToggle={canonicalToggle}
-      dependencyContext={toolParams}
-    />
-  )
-}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.test.ts

@@ -2,12 +2,37 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
+
-import {
+interface StoredTool {
-  isCustomToolAlreadySelected,
+  type: string
-  isMcpToolAlreadySelected,
+  title?: string
-  isWorkflowAlreadySelected,
+  toolId?: string
-} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/utils'
+  params?: Record<string, string>
+  customToolId?: string
+  schema?: any
+  code?: string
+  operation?: string
+  usageControl?: 'auto' | 'force' | 'none'
+}
+
+const isMcpToolAlreadySelected = (selectedTools: StoredTool[], mcpToolId: string): boolean => {
+  return selectedTools.some((tool) => tool.type === 'mcp' && tool.toolId === mcpToolId)
+}
+
+const isCustomToolAlreadySelected = (
+  selectedTools: StoredTool[],
+  customToolId: string
+): boolean => {
+  return selectedTools.some(
+    (tool) => tool.type === 'custom-tool' && tool.customToolId === customToolId
+  )
+}
+
+const isWorkflowAlreadySelected = (selectedTools: StoredTool[], workflowId: string): boolean => {
+  return selectedTools.some(
+    (tool) => tool.type === 'workflow_input' && tool.params?.workflowId === workflowId
+  )
+}
 
 describe('isMcpToolAlreadySelected', () => {
   describe('basic functionality', () => {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types.ts

@@ -1,31 +0,0 @@
-/**
- * Represents a tool selected and configured in the workflow
- *
- * @remarks
- * For custom tools (new format), we only store: type, customToolId, usageControl, isExpanded.
- * Everything else (title, schema, code) is loaded dynamically from the database.
- * Legacy custom tools with inline schema/code are still supported for backwards compatibility.
- */
-export interface StoredTool {
-  /** Block type identifier */
-  type: string
-  /** Display title for the tool (optional for new custom tool format) */
-  title?: string
-  /** Direct tool ID for execution (optional for new custom tool format) */
-  toolId?: string
-  /** Parameter values configured by the user (optional for new custom tool format) */
-  params?: Record<string, string>
-  /** Whether the tool details are expanded in UI */
-  isExpanded?: boolean
-  /** Database ID for custom tools (new format - reference only) */
-  customToolId?: string
-  /** Tool schema for custom tools (legacy format - inline JSON schema) */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  schema?: Record<string, any>
-  /** Implementation code for custom tools (legacy format - inline) */
-  code?: string
-  /** Selected operation for multi-operation tools */
-  operation?: string
-  /** Tool usage control mode for LLM */
-  usageControl?: 'auto' | 'force' | 'none'
-}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/utils.ts

@@ -1,32 +0,0 @@
-import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
-
-/**
- * Checks if an MCP tool is already selected.
- */
-export function isMcpToolAlreadySelected(selectedTools: StoredTool[], mcpToolId: string): boolean {
-  return selectedTools.some((tool) => tool.type === 'mcp' && tool.toolId === mcpToolId)
-}
-
-/**
- * Checks if a custom tool is already selected.
- */
-export function isCustomToolAlreadySelected(
-  selectedTools: StoredTool[],
-  customToolId: string
-): boolean {
-  return selectedTools.some(
-    (tool) => tool.type === 'custom-tool' && tool.customToolId === customToolId
-  )
-}
-
-/**
- * Checks if a workflow is already selected.
- */
-export function isWorkflowAlreadySelected(
-  selectedTools: StoredTool[],
-  workflowId: string
-): boolean {
-  return selectedTools.some(
-    (tool) => tool.type === 'workflow_input' && tool.params?.workflowId === workflowId
-  )
-}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx

@@ -3,6 +3,7 @@ import { isEqual } from 'lodash'
 import { AlertTriangle, ArrowLeftRight, ArrowUp, Check, Clipboard } from 'lucide-react'
 import { Button, Input, Label, Tooltip } from '@/components/emcn/components'
 import { cn } from '@/lib/core/utils/cn'
+import type { FieldDiffStatus } from '@/lib/workflows/diff/types'
 import {
   CheckboxList,
   Code,
@@ -68,15 +69,13 @@ interface SubBlockProps {
   isPreview?: boolean
   subBlockValues?: Record<string, any>
   disabled?: boolean
+  fieldDiffStatus?: FieldDiffStatus
   allowExpandInPreview?: boolean
   canonicalToggle?: {
     mode: 'basic' | 'advanced'
     disabled?: boolean
     onToggle?: () => void
   }
-  labelSuffix?: React.ReactNode
-  /** Provides sibling values for dependency resolution in non-preview contexts (e.g. tool-input) */
-  dependencyContext?: Record<string, unknown>
 }
 
 /**
@@ -163,14 +162,16 @@ const getPreviewValue = (
 /**
  * Renders the label with optional validation and description tooltips.
  *
+ * @remarks
+ * Handles JSON validation indicators for code blocks and required field markers.
+ * Includes inline AI generate button when wand is enabled.
+ *
  * @param config - The sub-block configuration defining the label content
  * @param isValidJson - Whether the JSON content is valid (for code blocks)
  * @param subBlockValues - Current values of all subblocks for evaluating conditional requirements
- * @param wandState - State and handlers for the inline AI generate feature
+ * @param wandState - Optional state and handlers for the AI wand feature
- * @param canonicalToggle - Metadata and handlers for the basic/advanced mode toggle
+ * @param canonicalToggle - Optional canonical toggle metadata and handlers
- * @param canonicalToggleIsDisabled - Whether the canonical toggle is disabled (includes dependsOn gating)
+ * @param canonicalToggleIsDisabled - Whether the canonical toggle is disabled
- * @param copyState - State and handler for the copy-to-clipboard button
- * @param labelSuffix - Additional content rendered after the label text
  * @returns The label JSX element, or `null` for switch types or when no title is defined
  */
 const renderLabel = (
@@ -201,8 +202,7 @@ const renderLabel = (
     showCopyButton: boolean
     copied: boolean
     onCopy: () => void
-  },
+  }
-  labelSuffix?: React.ReactNode
 ): JSX.Element | null => {
   if (config.type === 'switch') return null
   if (!config.title) return null
@@ -215,10 +215,9 @@ const renderLabel = (
 
   return (
     <div className='flex items-center justify-between gap-[6px] pl-[2px]'>
-      <Label className='flex items-baseline gap-[6px] whitespace-nowrap'>
+      <Label className='flex items-center gap-[6px] whitespace-nowrap'>
         {config.title}
         {required && <span className='ml-0.5'>*</span>}
-        {labelSuffix}
         {config.type === 'code' &&
           config.language === 'json' &&
           !isValidJson &&
@@ -384,25 +383,28 @@ const arePropsEqual = (prevProps: SubBlockProps, nextProps: SubBlockProps): bool
     prevProps.isPreview === nextProps.isPreview &&
     valueEqual &&
     prevProps.disabled === nextProps.disabled &&
+    prevProps.fieldDiffStatus === nextProps.fieldDiffStatus &&
     prevProps.allowExpandInPreview === nextProps.allowExpandInPreview &&
-    canonicalToggleEqual &&
+    canonicalToggleEqual
-    prevProps.labelSuffix === nextProps.labelSuffix &&
-    prevProps.dependencyContext === nextProps.dependencyContext
   )
 }
 
 /**
  * Renders a single workflow sub-block input based on config.type.
  *
+ * @remarks
+ * Supports multiple input types including short-input, long-input, dropdown,
+ * combobox, slider, table, code, switch, tool-input, and many more.
+ * Handles preview mode, disabled states, and AI wand generation.
+ *
  * @param blockId - The parent block identifier
  * @param config - Configuration defining the input type and properties
  * @param isPreview - Whether to render in preview mode
  * @param subBlockValues - Current values of all subblocks
  * @param disabled - Whether the input is disabled
+ * @param fieldDiffStatus - Optional diff status for visual indicators
  * @param allowExpandInPreview - Whether to allow expanding in preview mode
- * @param canonicalToggle - Metadata and handlers for the basic/advanced mode toggle
+ * @returns The rendered sub-block input component
- * @param labelSuffix - Additional content rendered after the label text
- * @param dependencyContext - Sibling values for dependency resolution in non-preview contexts (e.g. tool-input)
  */
 function SubBlockComponent({
   blockId,
@@ -410,10 +412,9 @@ function SubBlockComponent({
   isPreview = false,
   subBlockValues,
   disabled = false,
+  fieldDiffStatus,
   allowExpandInPreview,
   canonicalToggle,
-  labelSuffix,
-  dependencyContext,
 }: SubBlockProps): JSX.Element {
   const [isValidJson, setIsValidJson] = useState(true)
   const [isSearchActive, setIsSearchActive] = useState(false)
@@ -422,6 +423,7 @@ function SubBlockComponent({
   const searchInputRef = useRef<HTMLInputElement>(null)
   const wandControlRef = useRef<WandControlHandlers | null>(null)
 
+  // Use webhook management hook when config has useWebhookUrl enabled
   const webhookManagement = useWebhookManagement({
     blockId,
     triggerId: undefined,
@@ -508,12 +510,10 @@ function SubBlockComponent({
     | null
     | undefined
 
-  const contextValues = dependencyContext ?? (isPreview ? subBlockValues : undefined)
-
   const { finalDisabled: gatedDisabled } = useDependsOnGate(blockId, config, {
     disabled,
     isPreview,
-    previewContextValues: contextValues,
+    previewContextValues: isPreview ? subBlockValues : undefined,
   })
 
   const isDisabled = gatedDisabled
@@ -797,7 +797,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -809,7 +809,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -821,7 +821,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -833,7 +833,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -845,7 +845,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -868,7 +868,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue as any}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -880,7 +880,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue as any}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -892,7 +892,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue as any}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -917,7 +917,7 @@ function SubBlockComponent({
             isPreview={isPreview}
             previewValue={previewValue as any}
             disabled={isDisabled}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -953,7 +953,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -987,7 +987,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue as any}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -999,7 +999,7 @@ function SubBlockComponent({
             disabled={isDisabled}
             isPreview={isPreview}
             previewValue={previewValue}
-            previewContextValues={contextValues}
+            previewContextValues={isPreview ? subBlockValues : undefined}
           />
         )
 
@@ -1059,8 +1059,7 @@ function SubBlockComponent({
           showCopyButton: Boolean(config.showCopyButton && config.useWebhookUrl),
           copied,
           onCopy: handleCopy,
-        },
+        }
-        labelSuffix
       )}
       {renderInput()}
     </div>

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

@@ -571,6 +571,7 @@ export function Editor() {
                           isPreview={false}
                           subBlockValues={subBlockState}
                           disabled={!canEditBlock}
+                          fieldDiffStatus={undefined}
                           allowExpandInPreview={false}
                           canonicalToggle={
                             isCanonicalSwap && canonicalMode && canonicalId
@@ -634,6 +635,7 @@ export function Editor() {
                           isPreview={false}
                           subBlockValues={subBlockState}
                           disabled={!canEditBlock}
+                          fieldDiffStatus={undefined}
                           allowExpandInPreview={false}
                         />
                         {index < advancedOnlySubBlocks.length - 1 && (

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

@@ -106,6 +106,31 @@ const isPlainObject = (value: unknown): value is Record<string, unknown> => {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
+/**
+ * Parse subblock values that may arrive as JSON strings or already-materialized arrays.
+ */
+const parseStructuredArrayValue = (value: unknown): Array<Record<string, unknown>> | null => {
+  if (Array.isArray(value)) {
+    return value.filter(
+      (item): item is Record<string, unknown> => typeof item === 'object' && item !== null
+    )
+  }
+  if (typeof value !== 'string') {
+    return null
+  }
+  try {
+    const parsed = JSON.parse(value)
+    if (!Array.isArray(parsed)) {
+      return null
+    }
+    return parsed.filter(
+      (item): item is Record<string, unknown> => typeof item === 'object' && item !== null
+    )
+  } catch {
+    return null
+  }
+}
+
 /**
  * Type guard for variable assignments array
  */
@@ -961,25 +986,21 @@ export const WorkflowBlock = memo(function WorkflowBlock({
     if (type !== 'condition') return [] as { id: string; title: string; value: string }[]
 
     const conditionsValue = subBlockState.conditions?.value
-    const raw = typeof conditionsValue === 'string' ? conditionsValue : undefined
+    const parsed = parseStructuredArrayValue(conditionsValue)
-
+    if (parsed && parsed.length > 0) {
-    try {
+      return parsed.map((item, index) => {
-      if (raw) {
+        const conditionId = typeof item.id === 'string' ? item.id : `${id}-cond-${index}`
-        const parsed = JSON.parse(raw) as unknown
-        if (Array.isArray(parsed)) {
-          return parsed.map((item: unknown, index: number) => {
-            const conditionItem = item as { id?: string; value?: unknown }
         const title = index === 0 ? 'if' : index === parsed.length - 1 ? 'else' : 'else if'
         return {
-              id: conditionItem?.id ?? `${id}-cond-${index}`,
+          id: conditionId,
           title,
-              value: typeof conditionItem?.value === 'string' ? conditionItem.value : '',
+          value: typeof item.value === 'string' ? item.value : '',
         }
       })
     }
-      }
+
-    } catch (error) {
+    if (typeof conditionsValue === 'string' && conditionsValue.trim()) {
-      logger.warn('Failed to parse condition subblock value', { error, blockId: id })
+      logger.warn('Failed to parse condition subblock value', { blockId: id })
     }
 
     return [
@@ -997,24 +1018,16 @@ export const WorkflowBlock = memo(function WorkflowBlock({
     if (type !== 'router_v2') return [] as { id: string; value: string }[]
 
     const routesValue = subBlockState.routes?.value
-    const raw = typeof routesValue === 'string' ? routesValue : undefined
+    const parsed = parseStructuredArrayValue(routesValue)
+    if (parsed && parsed.length > 0) {
+      return parsed.map((item, index) => ({
+        id: typeof item.id === 'string' ? item.id : `${id}-route${index + 1}`,
+        value: typeof item.value === 'string' ? item.value : '',
+      }))
+    }
 
-    try {
+    if (typeof routesValue === 'string' && routesValue.trim()) {
-      if (raw) {
+      logger.warn('Failed to parse router routes value', { blockId: id })
-        const parsed = JSON.parse(raw) as unknown
-        if (Array.isArray(parsed)) {
-          return parsed.map((item: unknown, index: number) => {
-            const routeItem = item as { id?: string; value?: string }
-            return {
-              // Use stable ID format that matches ConditionInput's generateStableId
-              id: routeItem?.id ?? `${id}-route${index + 1}`,
-              value: routeItem?.value ?? '',
-            }
-          })
-        }
-      }
-    } catch (error) {
-      logger.warn('Failed to parse router routes value', { error, blockId: id })
     }
 
     // Fallback must match ConditionInput's default: generateStableId(blockId, 'route1') = `${blockId}-route1`

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

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

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

@@ -72,6 +72,31 @@ function extractValue(entry: SubBlockValueEntry | unknown): unknown {
   return entry
 }
 
+/**
+ * Parse subblock values that may be JSON strings or already-materialized arrays.
+ */
+function parseStructuredArrayValue(value: unknown): Array<Record<string, unknown>> | null {
+  if (Array.isArray(value)) {
+    return value.filter(
+      (item): item is Record<string, unknown> => typeof item === 'object' && item !== null
+    )
+  }
+  if (typeof value !== 'string') {
+    return null
+  }
+  try {
+    const parsed = JSON.parse(value)
+    if (!Array.isArray(parsed)) {
+      return null
+    }
+    return parsed.filter(
+      (item): item is Record<string, unknown> => typeof item === 'object' && item !== null
+    )
+  } catch {
+    return null
+  }
+}
+
 interface SubBlockRowProps {
   title: string
   value?: string
@@ -223,12 +248,7 @@ function resolveToolsDisplay(
  * - Resolves tool names from block registry
  * - Shows '-' for other selector types that need hydration
  */
-const SubBlockRow = memo(function SubBlockRow({
+function SubBlockRow({ title, value, subBlock, rawValue }: SubBlockRowProps) {
-  title,
-  value,
-  subBlock,
-  rawValue,
-}: SubBlockRowProps) {
   const isPasswordField = subBlock?.password === true
   const maskedValue = isPasswordField && value && value !== '-' ? '•••' : null
 
@@ -260,7 +280,7 @@ const SubBlockRow = memo(function SubBlockRow({
       )}
     </div>
   )
-})
+}
 
 /**
  * Preview block component for workflow visualization.
@@ -352,26 +372,17 @@ function WorkflowPreviewBlockInner({ data }: NodeProps<WorkflowPreviewBlockData>
     if (lightweight) return defaultRows
 
     const conditionsValue = rawValues.conditions
-    const raw = typeof conditionsValue === 'string' ? conditionsValue : undefined
+    const parsed = parseStructuredArrayValue(conditionsValue)
-
+    if (parsed && parsed.length > 0) {
-    try {
+      return parsed.map((item, index) => {
-      if (raw) {
-        const parsed = JSON.parse(raw) as unknown
-        if (Array.isArray(parsed)) {
-          return parsed.map((item: unknown, index: number) => {
-            const conditionItem = item as { id?: string; value?: unknown }
         const title = index === 0 ? 'if' : index === parsed.length - 1 ? 'else' : 'else if'
         return {
-              id: conditionItem?.id ?? `cond-${index}`,
+          id: typeof item.id === 'string' ? item.id : `cond-${index}`,
           title,
-              value: typeof conditionItem?.value === 'string' ? conditionItem.value : '',
+          value: typeof item.value === 'string' ? item.value : '',
         }
       })
     }
-      }
-    } catch {
-      /* empty */
-    }
 
     return defaultRows
   }, [type, rawValues, lightweight])
@@ -389,23 +400,12 @@ function WorkflowPreviewBlockInner({ data }: NodeProps<WorkflowPreviewBlockData>
     if (lightweight) return defaultRows
 
     const routesValue = rawValues.routes
-    const raw = typeof routesValue === 'string' ? routesValue : undefined
+    const parsed = parseStructuredArrayValue(routesValue)
-
+    if (parsed && parsed.length > 0) {
-    try {
+      return parsed.map((item, index) => ({
-      if (raw) {
+        id: typeof item.id === 'string' ? item.id : `route${index + 1}`,
-        const parsed = JSON.parse(raw) as unknown
+        value: typeof item.value === 'string' ? item.value : '',
-        if (Array.isArray(parsed)) {
+      }))
-          return parsed.map((item: unknown, index: number) => {
-            const routeItem = item as { id?: string; value?: string }
-            return {
-              id: routeItem?.id ?? `route${index + 1}`,
-              value: routeItem?.value ?? '',
-            }
-          })
-        }
-      }
-    } catch {
-      /* empty */
     }
 
     return defaultRows

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/components/index.ts

@@ -1,4 +1,3 @@
 export { CancelSubscription } from './cancel-subscription'
 export { CreditBalance } from './credit-balance'
 export { PlanCard, type PlanCardProps, type PlanFeature } from './plan-card'
-export { ReferralCode } from './referral-code'

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/components/referral-code/index.ts

@@ -1 +0,0 @@
-export { ReferralCode } from './referral-code'

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/components/referral-code/referral-code.tsx

@@ -1,103 +0,0 @@
-'use client'
-
-import { useState } from 'react'
-import { createLogger } from '@sim/logger'
-import { Button, Input, Label } from '@/components/emcn'
-
-const logger = createLogger('ReferralCode')
-
-interface ReferralCodeProps {
-  onRedeemComplete?: () => void
-}
-
-/**
- * Inline referral/promo code entry field with redeem button.
- * One-time use per account — shows success or "already redeemed" state.
- */
-export function ReferralCode({ onRedeemComplete }: ReferralCodeProps) {
-  const [code, setCode] = useState('')
-  const [isRedeeming, setIsRedeeming] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const [success, setSuccess] = useState<{ bonusAmount: number } | null>(null)
-
-  const handleRedeem = async () => {
-    const trimmed = code.trim()
-    if (!trimmed || isRedeeming) return
-
-    setIsRedeeming(true)
-    setError(null)
-
-    try {
-      const response = await fetch('/api/referral-code/redeem', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ code: trimmed }),
-      })
-
-      const data = await response.json()
-
-      if (!response.ok) {
-        throw new Error(data.error || 'Failed to redeem code')
-      }
-
-      if (data.redeemed) {
-        setSuccess({ bonusAmount: data.bonusAmount })
-        setCode('')
-        onRedeemComplete?.()
-      } else {
-        setError(data.error || 'Code could not be redeemed')
-      }
-    } catch (err) {
-      logger.error('Referral code redemption failed', { error: err })
-      setError(err instanceof Error ? err.message : 'Failed to redeem code')
-    } finally {
-      setIsRedeeming(false)
-    }
-  }
-
-  if (success) {
-    return (
-      <div className='flex items-center justify-between'>
-        <Label>Referral Code</Label>
-        <span className='text-[12px] text-[var(--text-secondary)]'>
-          +${success.bonusAmount} credits applied
-        </span>
-      </div>
-    )
-  }
-
-  return (
-    <div className='flex flex-col'>
-      <div className='flex items-center justify-between gap-[12px]'>
-        <Label className='shrink-0'>Referral Code</Label>
-        <div className='flex items-center gap-[8px]'>
-          <Input
-            type='text'
-            value={code}
-            onChange={(e) => {
-              setCode(e.target.value)
-              setError(null)
-            }}
-            onKeyDown={(e) => {
-              if (e.key === 'Enter') handleRedeem()
-            }}
-            placeholder='Enter code'
-            className='h-[32px] w-[140px] text-[12px]'
-            disabled={isRedeeming}
-          />
-          <Button
-            variant='active'
-            className='h-[32px] shrink-0 rounded-[6px] text-[12px]'
-            onClick={handleRedeem}
-            disabled={isRedeeming || !code.trim()}
-          >
-            {isRedeeming ? 'Redeeming...' : 'Redeem'}
-          </Button>
-        </div>
-      </div>
-      <div className='mt-[4px] min-h-[18px] text-right'>
-        {error && <span className='text-[11px] text-[var(--text-error)]'>{error}</span>}
-      </div>
-    </div>
-  )
-}

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/subscription.tsx

@@ -17,7 +17,6 @@ import {
   CancelSubscription,
   CreditBalance,
   PlanCard,
-  ReferralCode,
 } from '@/app/workspace/[workspaceId]/w/components/sidebar/components/settings-modal/components/subscription/components'
 import {
   ENTERPRISE_PLAN_FEATURES,
@@ -550,10 +549,6 @@ export function Subscription() {
         />
       )}
 
-      {!subscription.isEnterprise && (
-        <ReferralCode onRedeemComplete={() => refetchSubscription()} />
-      )}
-
       {/* Next Billing Date - hidden from team members */}
       {subscription.isPaid &&
         subscriptionData?.data?.periodEnd &&

apps/sim/app/workspace/page.tsx

@@ -4,14 +4,12 @@ import { useEffect } from 'react'
 import { createLogger } from '@sim/logger'
 import { useRouter } from 'next/navigation'
 import { useSession } from '@/lib/auth/auth-client'
-import { useReferralAttribution } from '@/hooks/use-referral-attribution'
 
 const logger = createLogger('WorkspacePage')
 
 export default function WorkspacePage() {
   const router = useRouter()
   const { data: session, isPending } = useSession()
-  useReferralAttribution()
 
   useEffect(() => {
     const redirectToFirstWorkspace = async () => {

apps/sim/blocks/blocks/agent.ts

@@ -2,10 +2,11 @@ import { createLogger } from '@sim/logger'
 import { AgentIcon } from '@/components/icons'
 import type { BlockConfig } from '@/blocks/types'
 import { AuthMode } from '@/blocks/types'
-import { getApiKeyCondition, getModelOptions } from '@/blocks/utils'
+import { getApiKeyCondition } from '@/blocks/utils'
 import {
   getBaseModelProviders,
   getMaxTemperature,
+  getProviderIcon,
   getReasoningEffortValuesForModel,
   getThinkingLevelsForModel,
   getVerbosityValuesForModel,
@@ -17,6 +18,7 @@ import {
   providers,
   supportsTemperature,
 } from '@/providers/utils'
+import { useProvidersStore } from '@/stores/providers'
 import type { ToolResponse } from '@/tools/types'
 
 const logger = createLogger('AgentBlock')
@@ -119,7 +121,21 @@ Return ONLY the JSON array.`,
       placeholder: 'Type or select a model...',
       required: true,
       defaultValue: 'claude-sonnet-4-5',
-      options: getModelOptions,
+      options: () => {
+        const providersState = useProvidersStore.getState()
+        const baseModels = providersState.providers.base.models
+        const ollamaModels = providersState.providers.ollama.models
+        const vllmModels = providersState.providers.vllm.models
+        const openrouterModels = providersState.providers.openrouter.models
+        const allModels = Array.from(
+          new Set([...baseModels, ...ollamaModels, ...vllmModels, ...openrouterModels])
+        )
+
+        return allModels.map((model) => {
+          const icon = getProviderIcon(model)
+          return { label: model, id: model, ...(icon && { icon }) }
+        })
+      },
     },
     {
       id: 'vertexCredential',

apps/sim/blocks/blocks/evaluator.ts

@@ -1,13 +1,10 @@
 import { createLogger } from '@sim/logger'
 import { ChartBarIcon } from '@/components/icons'
 import type { BlockConfig, ParamType } from '@/blocks/types'
-import {
+import { getProviderCredentialSubBlocks, PROVIDER_CREDENTIAL_INPUTS } from '@/blocks/utils'
-  getModelOptions,
-  getProviderCredentialSubBlocks,
-  PROVIDER_CREDENTIAL_INPUTS,
-} from '@/blocks/utils'
 import type { ProviderId } from '@/providers/types'
-import { getBaseModelProviders } from '@/providers/utils'
+import { getBaseModelProviders, getProviderIcon } from '@/providers/utils'
+import { useProvidersStore } from '@/stores/providers/store'
 import type { ToolResponse } from '@/tools/types'
 
 const logger = createLogger('EvaluatorBlock')
@@ -178,7 +175,21 @@ export const EvaluatorBlock: BlockConfig<EvaluatorResponse> = {
       placeholder: 'Type or select a model...',
       required: true,
       defaultValue: 'claude-sonnet-4-5',
-      options: getModelOptions,
+      options: () => {
+        const providersState = useProvidersStore.getState()
+        const baseModels = providersState.providers.base.models
+        const ollamaModels = providersState.providers.ollama.models
+        const vllmModels = providersState.providers.vllm.models
+        const openrouterModels = providersState.providers.openrouter.models
+        const allModels = Array.from(
+          new Set([...baseModels, ...ollamaModels, ...vllmModels, ...openrouterModels])
+        )
+
+        return allModels.map((model) => {
+          const icon = getProviderIcon(model)
+          return { label: model, id: model, ...(icon && { icon }) }
+        })
+      },
     },
     ...getProviderCredentialSubBlocks(),
     {

apps/sim/blocks/blocks/google_books.ts

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

apps/sim/blocks/blocks/guardrails.ts

@@ -1,10 +1,8 @@
 import { ShieldCheckIcon } from '@/components/icons'
 import type { BlockConfig } from '@/blocks/types'
-import {
+import { getProviderCredentialSubBlocks, PROVIDER_CREDENTIAL_INPUTS } from '@/blocks/utils'
-  getModelOptions,
+import { getProviderIcon } from '@/providers/utils'
-  getProviderCredentialSubBlocks,
+import { useProvidersStore } from '@/stores/providers/store'
-  PROVIDER_CREDENTIAL_INPUTS,
-} from '@/blocks/utils'
 import type { ToolResponse } from '@/tools/types'
 
 export interface GuardrailsResponse extends ToolResponse {
@@ -113,7 +111,21 @@ Return ONLY the regex pattern - no explanations, no quotes, no forward slashes,
       type: 'combobox',
       placeholder: 'Type or select a model...',
       required: true,
-      options: getModelOptions,
+      options: () => {
+        const providersState = useProvidersStore.getState()
+        const baseModels = providersState.providers.base.models
+        const ollamaModels = providersState.providers.ollama.models
+        const vllmModels = providersState.providers.vllm.models
+        const openrouterModels = providersState.providers.openrouter.models
+        const allModels = Array.from(
+          new Set([...baseModels, ...ollamaModels, ...vllmModels, ...openrouterModels])
+        )
+
+        return allModels.map((model) => {
+          const icon = getProviderIcon(model)
+          return { label: model, id: model, ...(icon && { icon }) }
+        })
+      },
       condition: {
         field: 'validationType',
         value: ['hallucination'],

apps/sim/blocks/blocks/router.ts

@@ -1,12 +1,9 @@
 import { ConnectIcon } from '@/components/icons'
 import { AuthMode, type BlockConfig } from '@/blocks/types'
-import {
+import { getProviderCredentialSubBlocks, PROVIDER_CREDENTIAL_INPUTS } from '@/blocks/utils'
-  getModelOptions,
-  getProviderCredentialSubBlocks,
-  PROVIDER_CREDENTIAL_INPUTS,
-} from '@/blocks/utils'
 import type { ProviderId } from '@/providers/types'
-import { getBaseModelProviders } from '@/providers/utils'
+import { getBaseModelProviders, getProviderIcon } from '@/providers/utils'
+import { useProvidersStore } from '@/stores/providers'
 import type { ToolResponse } from '@/tools/types'
 
 interface RouterResponse extends ToolResponse {
@@ -137,6 +134,25 @@ Respond with a JSON object containing:
 - reasoning: A brief explanation (1-2 sentences) of why you chose this route`
 }
 
+/**
+ * Helper to get model options for both router versions.
+ */
+const getModelOptions = () => {
+  const providersState = useProvidersStore.getState()
+  const baseModels = providersState.providers.base.models
+  const ollamaModels = providersState.providers.ollama.models
+  const vllmModels = providersState.providers.vllm.models
+  const openrouterModels = providersState.providers.openrouter.models
+  const allModels = Array.from(
+    new Set([...baseModels, ...ollamaModels, ...vllmModels, ...openrouterModels])
+  )
+
+  return allModels.map((model) => {
+    const icon = getProviderIcon(model)
+    return { label: model, id: model, ...(icon && { icon }) }
+  })
+}
+
 /**
  * Legacy Router Block (block-based routing).
  * Hidden from toolbar but still supported for existing workflows.

apps/sim/blocks/blocks/s3.ts

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

apps/sim/blocks/blocks/translate.ts

@@ -1,10 +1,8 @@
 import { TranslateIcon } from '@/components/icons'
 import { AuthMode, type BlockConfig } from '@/blocks/types'
-import {
+import { getProviderCredentialSubBlocks, PROVIDER_CREDENTIAL_INPUTS } from '@/blocks/utils'
-  getModelOptions,
+import { getProviderIcon } from '@/providers/utils'
-  getProviderCredentialSubBlocks,
+import { useProvidersStore } from '@/stores/providers/store'
-  PROVIDER_CREDENTIAL_INPUTS,
-} from '@/blocks/utils'
 
 const getTranslationPrompt = (targetLanguage: string) =>
   `Translate the following text into ${targetLanguage || 'English'}. Output ONLY the translated text with no additional commentary, explanations, or notes.`
@@ -40,7 +38,18 @@ export const TranslateBlock: BlockConfig = {
       type: 'combobox',
       placeholder: 'Type or select a model...',
       required: true,
-      options: getModelOptions,
+      options: () => {
+        const providersState = useProvidersStore.getState()
+        const baseModels = providersState.providers.base.models
+        const ollamaModels = providersState.providers.ollama.models
+        const openrouterModels = providersState.providers.openrouter.models
+        const allModels = Array.from(new Set([...baseModels, ...ollamaModels, ...openrouterModels]))
+
+        return allModels.map((model) => {
+          const icon = getProviderIcon(model)
+          return { label: model, id: model, ...(icon && { icon }) }
+        })
+      },
     },
     ...getProviderCredentialSubBlocks(),
     {

apps/sim/blocks/registry.ts

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

apps/sim/blocks/types.ts

@@ -196,8 +196,6 @@ export interface SubBlockConfig {
   type: SubBlockType
   mode?: 'basic' | 'advanced' | 'both' | 'trigger' // Default is 'both' if not specified. 'trigger' means only shown in trigger mode
   canonicalParamId?: string
-  /** Controls parameter visibility in agent/tool-input context */
-  paramVisibility?: 'user-or-llm' | 'user-only' | 'llm-only' | 'hidden'
   required?:
     | boolean
     | {

apps/sim/blocks/utils.ts

@@ -1,32 +1,8 @@
 import { isHosted } from '@/lib/core/config/feature-flags'
 import type { BlockOutput, OutputFieldDefinition, SubBlockConfig } from '@/blocks/types'
-import {
+import { getHostedModels, getProviderFromModel, providers } from '@/providers/utils'
-  getHostedModels,
-  getProviderFromModel,
-  getProviderIcon,
-  providers,
-} from '@/providers/utils'
 import { useProvidersStore } from '@/stores/providers/store'
 
-/**
- * Returns model options for combobox subblocks, combining all provider sources.
- */
-export function getModelOptions() {
-  const providersState = useProvidersStore.getState()
-  const baseModels = providersState.providers.base.models
-  const ollamaModels = providersState.providers.ollama.models
-  const vllmModels = providersState.providers.vllm.models
-  const openrouterModels = providersState.providers.openrouter.models
-  const allModels = Array.from(
-    new Set([...baseModels, ...ollamaModels, ...vllmModels, ...openrouterModels])
-  )
-
-  return allModels.map((model) => {
-    const icon = getProviderIcon(model)
-    return { label: model, id: model, ...(icon && { icon }) }
-  })
-}
-
 /**
  * Checks if a field is included in the dependsOn config.
  * Handles both simple array format and object format with all/any fields.

apps/sim/components/emcn/components/code/code.tsx

@@ -1008,7 +1008,7 @@ const VirtualizedViewerInner = memo(function VirtualizedViewerInner({
  * Non-virtualized code viewer implementation.
  * Renders all lines directly without windowing.
  */
-const ViewerInner = memo(function ViewerInner({
+function ViewerInner({
   code,
   showGutter,
   language,
@@ -1181,7 +1181,7 @@ const ViewerInner = memo(function ViewerInner({
       </Content>
     </Container>
   )
-})
+}
 
 /**
  * Readonly code viewer with optional gutter and syntax highlighting.

apps/sim/components/icons.tsx

@@ -1157,21 +1157,6 @@ export function AirweaveIcon(props: SVGProps<SVGSVGElement>) {
   )
 }
 
-export function GoogleBooksIcon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg {...props} xmlns='http://www.w3.org/2000/svg' viewBox='0 0 478.633 540.068'>
-      <path
-        fill='#1C51A4'
-        d='M449.059,218.231L245.519,99.538l-0.061,193.23c0.031,1.504-0.368,2.977-1.166,4.204c-0.798,1.258-1.565,1.995-2.915,2.547c-1.35,0.552-2.792,0.706-4.204,0.399c-1.412-0.307-2.7-1.043-3.713-2.117l-69.166-70.609l-69.381,70.179c-1.013,0.982-2.301,1.657-3.652,1.903c-1.381,0.246-2.792,0.092-4.081-0.491c-1.289-0.583-1.626-0.522-2.394-1.749c-0.767-1.197-1.197-2.608-1.197-4.081L85.031,6.007l-2.915-1.289C43.973-11.638,0,16.409,0,59.891v420.306c0,46.029,49.312,74.782,88.775,51.767l360.285-210.138C488.491,298.782,488.491,241.246,449.059,218.231z'
-      />
-      <path
-        fill='#80D7FB'
-        d='M88.805,8.124c-2.179-1.289-4.419-2.363-6.659-3.345l0.123,288.663c0,1.442,0.43,2.854,1.197,4.081c0.767,1.197,1.872,2.148,3.161,2.731c1.289,0.583,2.7,0.736,4.081,0.491c1.381-0.246,2.639-0.921,3.652-1.903l69.749-69.688l69.811,69.749c1.013,1.074,2.301,1.81,3.713,2.117c1.412,0.307,2.884,0.153,4.204-0.399c1.319-0.552,2.455-1.565,3.253-2.792c0.798-1.258,1.197-2.731,1.166-4.204V99.998L88.805,8.124z'
-      />
-    </svg>
-  )
-}
-
 export function GoogleDocsIcon(props: SVGProps<SVGSVGElement>) {
   return (
     <svg

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

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

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

@@ -62,12 +62,9 @@ export class AgentBlockHandler implements BlockHandler {
     await validateModelProvider(ctx.userId, model, ctx)
 
     const providerId = getProviderFromModel(model)
-    const formattedTools = await this.formatTools(
+    const formattedTools = await this.formatTools(ctx, filteredInputs.tools || [])
-      ctx,
-      filteredInputs.tools || [],
-      block.canonicalModes
-    )
 
+    // Resolve skill metadata for progressive disclosure
     const skillInputs = filteredInputs.skills ?? []
     let skillMetadata: Array<{ name: string; description: string }> = []
     if (skillInputs.length > 0 && ctx.workspaceId) {
@@ -224,11 +221,7 @@ export class AgentBlockHandler implements BlockHandler {
     })
   }
 
-  private async formatTools(
+  private async formatTools(ctx: ExecutionContext, inputTools: ToolInput[]): Promise<any[]> {
-    ctx: ExecutionContext,
-    inputTools: ToolInput[],
-    canonicalModes?: Record<string, 'basic' | 'advanced'>
-  ): Promise<any[]> {
     if (!Array.isArray(inputTools)) return []
 
     const filtered = inputTools.filter((tool) => {
@@ -256,7 +249,7 @@ export class AgentBlockHandler implements BlockHandler {
           if (tool.type === 'custom-tool' && (tool.schema || tool.customToolId)) {
             return await this.createCustomTool(ctx, tool)
           }
-          return this.transformBlockTool(ctx, tool, canonicalModes)
+          return this.transformBlockTool(ctx, tool)
         } catch (error) {
           logger.error(`[AgentHandler] Error creating tool:`, { tool, error })
           return null
@@ -279,16 +272,15 @@ export class AgentBlockHandler implements BlockHandler {
     let code = tool.code
     let title = tool.title
 
-    if (tool.customToolId) {
+    if (tool.customToolId && !schema) {
       const resolved = await this.fetchCustomToolById(ctx, tool.customToolId)
-      if (resolved) {
+      if (!resolved) {
-        schema = resolved.schema
-        code = resolved.code
-        title = resolved.title
-      } else if (!schema) {
         logger.error(`Custom tool not found: ${tool.customToolId}`)
         return null
       }
+      schema = resolved.schema
+      code = resolved.code
+      title = resolved.title
     }
 
     if (!schema?.function) {
@@ -727,17 +719,12 @@ export class AgentBlockHandler implements BlockHandler {
     }
   }
 
-  private async transformBlockTool(
+  private async transformBlockTool(ctx: ExecutionContext, tool: ToolInput) {
-    ctx: ExecutionContext,
-    tool: ToolInput,
-    canonicalModes?: Record<string, 'basic' | 'advanced'>
-  ) {
     const transformedTool = await transformBlockTool(tool, {
       selectedOperation: tool.operation,
       getAllBlocks,
       getToolAsync: (toolId: string) => getToolAsync(toolId, ctx.workflowId),
       getTool,
-      canonicalModes,
     })
 
     if (transformedTool) {

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

@@ -2,7 +2,7 @@ import { db } from '@sim/db'
 import { account } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
-import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { getBaseUrl } from '@/lib/core/utils/urls'
 import { refreshTokenIfNeeded } from '@/app/api/auth/oauth/utils'
 import { generateRouterPrompt, generateRouterV2Prompt } from '@/blocks/blocks/router'
 import type { BlockOutput } from '@/blocks/types'
@@ -79,7 +79,7 @@ export class RouterBlockHandler implements BlockHandler {
     const providerId = getProviderFromModel(routerConfig.model)
 
     try {
-      const url = new URL('/api/providers', getInternalApiBaseUrl())
+      const url = new URL('/api/providers', getBaseUrl())
       if (ctx.userId) url.searchParams.set('userId', ctx.userId)
 
       const messages = [{ role: 'user', content: routerConfig.prompt }]
@@ -209,7 +209,7 @@ export class RouterBlockHandler implements BlockHandler {
     const providerId = getProviderFromModel(routerConfig.model)
 
     try {
-      const url = new URL('/api/providers', getInternalApiBaseUrl())
+      const url = new URL('/api/providers', getBaseUrl())
       if (ctx.userId) url.searchParams.set('userId', ctx.userId)
 
       const messages = [{ role: 'user', content: routerConfig.context }]

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

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

apps/sim/executor/utils/block-reference.test.ts

@@ -184,6 +184,48 @@ describe('resolveBlockReference', () => {
       const result = resolveBlockReference('start', ['input'], ctx)
       expect(result).toEqual({ value: undefined, blockId: 'block-1' })
     })
+
+    it('should allow nested access under json output schema fields', () => {
+      const ctx = createContext({
+        blockData: {},
+        blockOutputSchemas: {
+          'block-1': {
+            result: { type: 'json' },
+          },
+        },
+      })
+
+      const result = resolveBlockReference('start', ['result', 'emails', '0', 'subject'], ctx)
+      expect(result).toEqual({ value: undefined, blockId: 'block-1' })
+    })
+
+    it('should allow nested access under any output schema fields', () => {
+      const ctx = createContext({
+        blockData: {},
+        blockOutputSchemas: {
+          'block-1': {
+            payload: { type: 'any' },
+          },
+        },
+      })
+
+      const result = resolveBlockReference('start', ['payload', 'nested', 'key'], ctx)
+      expect(result).toEqual({ value: undefined, blockId: 'block-1' })
+    })
+
+    it('should allow nested access for arrays without explicit item schema', () => {
+      const ctx = createContext({
+        blockData: {},
+        blockOutputSchemas: {
+          'block-1': {
+            rows: { type: 'array' },
+          },
+        },
+      })
+
+      const result = resolveBlockReference('start', ['rows', '0', 'value'], ctx)
+      expect(result).toEqual({ value: undefined, blockId: 'block-1' })
+    })
   })
 
   describe('without schema (pass-through mode)', () => {

apps/sim/executor/utils/block-reference.ts

@@ -53,6 +53,24 @@ function getProperties(schema: unknown): Record<string, unknown> | undefined {
     : undefined
 }
 
+function getSchemaType(schema: unknown): string | null {
+  if (typeof schema !== 'object' || schema === null) return null
+  const rawType = (schema as { type?: unknown }).type
+  return typeof rawType === 'string' ? rawType.toLowerCase() : null
+}
+
+function isDynamicSchemaNode(schema: unknown): boolean {
+  const schemaType = getSchemaType(schema)
+  if (!schemaType) return false
+  if (schemaType === 'any' || schemaType === 'json') {
+    return true
+  }
+  if (schemaType === 'object' && !getProperties(schema)) {
+    return true
+  }
+  return false
+}
+
 function lookupField(schema: unknown, fieldName: string): unknown | undefined {
   if (typeof schema !== 'object' || schema === null) return undefined
   const typed = schema as Record<string, unknown>
@@ -83,6 +101,12 @@ function isPathInSchema(schema: OutputSchema | undefined, pathParts: string[]):
       return false
     }
 
+    if (isDynamicSchemaNode(current)) {
+      // Dynamic schema node (json/any/object-without-properties):
+      // allow deeper traversal without strict field validation.
+      return true
+    }
+
     if (/^\d+$/.test(part)) {
       if (isFileType(current)) {
         const nextPart = pathParts[i + 1]
@@ -94,7 +118,12 @@ function isPathInSchema(schema: OutputSchema | undefined, pathParts: string[]):
         )
       }
       if (isArrayType(current)) {
-        current = getArrayItems(current)
+        const items = getArrayItems(current)
+        if (items === undefined) {
+          // Arrays without declared item schema are treated as dynamic.
+          return true
+        }
+        current = items
       }
       continue
     }
@@ -116,6 +145,10 @@ function isPathInSchema(schema: OutputSchema | undefined, pathParts: string[]):
       }
 
       current = isArrayType(fieldDef) ? getArrayItems(fieldDef) : fieldDef
+      if (current === undefined) {
+        // Array/object without explicit shape after this segment.
+        return true
+      }
       continue
     }
 

apps/sim/executor/utils/http.ts

@@ -1,5 +1,5 @@
 import { generateInternalToken } from '@/lib/auth/internal'
-import { getBaseUrl, getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { getBaseUrl } from '@/lib/core/utils/urls'
 import { HTTP } from '@/executor/constants'
 
 export async function buildAuthHeaders(): Promise<Record<string, string>> {
@@ -16,8 +16,7 @@ export async function buildAuthHeaders(): Promise<Record<string, string>> {
 }
 
 export function buildAPIUrl(path: string, params?: Record<string, string>): URL {
-  const baseUrl = path.startsWith('/api/') ? getInternalApiBaseUrl() : getBaseUrl()
+  const url = new URL(path, getBaseUrl())
-  const url = new URL(path, baseUrl)
 
   if (params) {
     for (const [key, value] of Object.entries(params)) {

apps/sim/hooks/queries/deployments.ts

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

apps/sim/hooks/queries/logs.ts

@@ -1,10 +1,4 @@
-import {
+import { keepPreviousData, useInfiniteQuery, useQuery } from '@tanstack/react-query'
-  keepPreviousData,
-  type QueryClient,
-  useInfiniteQuery,
-  useQuery,
-  useQueryClient,
-} from '@tanstack/react-query'
 import { getEndDateFromTimeRange, getStartDateFromTimeRange } from '@/lib/logs/filters'
 import { parseQuery, queryToApiParams } from '@/lib/logs/query-parser'
 import type {
@@ -152,45 +146,17 @@ export function useLogsList(
 
 interface UseLogDetailOptions {
   enabled?: boolean
-  refetchInterval?:
+  refetchInterval?: number | false
-    | number
-    | false
-    | ((query: { state: { data?: WorkflowLog } }) => number | false | undefined)
 }
 
 export function useLogDetail(logId: string | undefined, options?: UseLogDetailOptions) {
-  const queryClient = useQueryClient()
   return useQuery({
     queryKey: logKeys.detail(logId),
     queryFn: () => fetchLogDetail(logId as string),
     enabled: Boolean(logId) && (options?.enabled ?? true),
     refetchInterval: options?.refetchInterval ?? false,
     staleTime: 30 * 1000,
-    initialData: () => {
+    placeholderData: keepPreviousData,
-      if (!logId) return undefined
-      const listQueries = queryClient.getQueriesData<{
-        pages: { logs: WorkflowLog[] }[]
-      }>({
-        queryKey: logKeys.lists(),
-      })
-      for (const [, data] of listQueries) {
-        const match = data?.pages?.flatMap((p) => p.logs).find((l) => l.id === logId)
-        if (match) return match
-      }
-      return undefined
-    },
-    initialDataUpdatedAt: 0,
-  })
-}
-
-/**
- * Prefetches log detail data on hover for instant panel rendering on click.
- */
-export function prefetchLogDetail(queryClient: QueryClient, logId: string) {
-  queryClient.prefetchQuery({
-    queryKey: logKeys.detail(logId),
-    queryFn: () => fetchLogDetail(logId),
-    staleTime: 30 * 1000,
   })
 }
 

apps/sim/hooks/queries/workflows.ts

@@ -642,10 +642,6 @@ export function useDeployChildWorkflow() {
       queryClient.invalidateQueries({
         queryKey: workflowKeys.deploymentStatus(variables.workflowId),
       })
-      // Invalidate workflow state so tool input mappings refresh
-      queryClient.invalidateQueries({
-        queryKey: workflowKeys.state(variables.workflowId),
-      })
       // Also invalidate deployment queries
       queryClient.invalidateQueries({
         queryKey: deploymentKeys.info(variables.workflowId),

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

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

apps/sim/hooks/use-referral-attribution.ts

@@ -1,46 +0,0 @@
-'use client'
-
-import { useEffect, useRef } from 'react'
-import { createLogger } from '@sim/logger'
-
-const logger = createLogger('ReferralAttribution')
-
-const COOKIE_NAME = 'sim_utm'
-
-const TERMINAL_REASONS = new Set([
-  'invalid_cookie',
-  'no_utm_cookie',
-  'no_matching_campaign',
-  'already_attributed',
-])
-
-/**
- * Fires a one-shot `POST /api/attribution` when a `sim_utm` cookie is present.
- * Retries on transient failures; stops on terminal outcomes.
- */
-export function useReferralAttribution() {
-  const calledRef = useRef(false)
-
-  useEffect(() => {
-    if (calledRef.current) return
-    if (!document.cookie.includes(COOKIE_NAME)) return
-
-    calledRef.current = true
-
-    fetch('/api/attribution', { method: 'POST' })
-      .then((res) => res.json())
-      .then((data) => {
-        if (data.attributed) {
-          logger.info('Referral attribution successful', { bonusAmount: data.bonusAmount })
-        } else if (data.error || TERMINAL_REASONS.has(data.reason)) {
-          logger.info('Referral attribution skipped', { reason: data.reason || data.error })
-        } else {
-          calledRef.current = false
-        }
-      })
-      .catch((err) => {
-        logger.warn('Referral attribution failed, will retry', { error: err })
-        calledRef.current = false
-      })
-  }, [])
-}

apps/sim/lib/billing/credits/bonus.ts

@@ -1,64 +0,0 @@
-import { db } from '@sim/db'
-import { organization, userStats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq, sql } from 'drizzle-orm'
-import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
-import type { DbOrTx } from '@/lib/db/types'
-
-const logger = createLogger('BonusCredits')
-
-/**
- * Apply bonus credits to a user (e.g. referral bonuses, promotional codes).
- *
- * Detects the user's current plan and routes credits accordingly:
- * - Free/Pro: adds to `userStats.creditBalance` and increments `currentUsageLimit`
- * - Team/Enterprise: adds to `organization.creditBalance` and increments `orgUsageLimit`
- *
- * Uses direct increment (not recalculation) so it works correctly for free-tier
- * users where `setUsageLimitForCredits` would compute planBase=0 and skip the update.
- *
- * @param tx - Optional Drizzle transaction context. When provided, all DB writes
- *             participate in the caller's transaction for atomicity.
- */
-export async function applyBonusCredits(
-  userId: string,
-  amount: number,
-  tx?: DbOrTx
-): Promise<void> {
-  const dbCtx = tx ?? db
-  const subscription = await getHighestPrioritySubscription(userId)
-  const isTeamOrEnterprise = subscription?.plan === 'team' || subscription?.plan === 'enterprise'
-
-  if (isTeamOrEnterprise && subscription?.referenceId) {
-    const orgId = subscription.referenceId
-
-    await dbCtx
-      .update(organization)
-      .set({
-        creditBalance: sql`${organization.creditBalance} + ${amount}`,
-        orgUsageLimit: sql`COALESCE(${organization.orgUsageLimit}, '0')::decimal + ${amount}`,
-      })
-      .where(eq(organization.id, orgId))
-
-    logger.info('Applied bonus credits to organization', {
-      userId,
-      organizationId: orgId,
-      plan: subscription.plan,
-      amount,
-    })
-  } else {
-    await dbCtx
-      .update(userStats)
-      .set({
-        creditBalance: sql`${userStats.creditBalance} + ${amount}`,
-        currentUsageLimit: sql`COALESCE(${userStats.currentUsageLimit}, '0')::decimal + ${amount}`,
-      })
-      .where(eq(userStats.userId, userId))
-
-    logger.info('Applied bonus credits to user', {
-      userId,
-      plan: subscription?.plan || 'free',
-      amount,
-    })
-  }
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

apps/sim/lib/copilot/constants.ts

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