v3

apps/docs/components/icons.tsx

@@ -5113,42 +5113,3 @@ export function PulseIcon(props: SVGProps<SVGSVGElement>) {
     </svg>
   )
 }
-
-export function CalComIcon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg
-      {...props}
-      width='101'
-      height='22'
-      viewBox='0 0 101 22'
-      fill='currentColor'
-      xmlns='http://www.w3.org/2000/svg'
-    >
-      <path
-        d='M10.0582 20.817C4.32115 20.817 0 16.2763 0 10.6704C0 5.04589 4.1005 0.467773 10.0582 0.467773C13.2209 0.467773 15.409 1.43945 17.1191 3.66311L14.3609 5.96151C13.2025 4.72822 11.805 4.11158 10.0582 4.11158C6.17833 4.11158 4.04533 7.08268 4.04533 10.6704C4.04533 14.2582 6.38059 17.1732 10.0582 17.1732C11.7866 17.1732 13.2577 16.5566 14.4161 15.3233L17.1375 17.7151C15.501 19.8453 13.2577 20.817 10.0582 20.817Z'
-        fill='#292929'
-      />
-      <path
-        d='M29.0161 5.88601H32.7304V20.4612H29.0161V18.331C28.2438 19.8446 26.9566 20.8536 24.4927 20.8536C20.5577 20.8536 17.4133 17.4341 17.4133 13.2297C17.4133 9.02528 20.5577 5.60571 24.4927 5.60571C26.9383 5.60571 28.2438 6.61477 29.0161 8.12835V5.88601ZM29.1264 13.2297C29.1264 10.95 27.5634 9.06266 25.0995 9.06266C22.7274 9.06266 21.1828 10.9686 21.1828 13.2297C21.1828 15.4346 22.7274 17.3967 25.0995 17.3967C27.5451 17.3967 29.1264 15.4907 29.1264 13.2297Z'
-        fill='#292929'
-      />
-      <path d='M35.3599 0H39.0742V20.4427H35.3599V0Z' fill='#292929' />
-      <path
-        d='M40.7291 18.5182C40.7291 17.3223 41.6853 16.3132 42.9908 16.3132C44.2964 16.3132 45.2158 17.3223 45.2158 18.5182C45.2158 19.7515 44.278 20.7605 42.9908 20.7605C41.7037 20.7605 40.7291 19.7515 40.7291 18.5182Z'
-        fill='#292929'
-      />
-      <path
-        d='M59.4296 18.1068C58.0505 19.7885 55.9543 20.8536 53.4719 20.8536C49.0404 20.8536 45.7858 17.4341 45.7858 13.2297C45.7858 9.02528 49.0404 5.60571 53.4719 5.60571C55.8623 5.60571 57.9402 6.61477 59.3193 8.20309L56.4508 10.6136C55.7336 9.71667 54.7958 9.04397 53.4719 9.04397C51.0999 9.04397 49.5553 10.95 49.5553 13.211C49.5553 15.472 51.0999 17.378 53.4719 17.378C54.9062 17.378 55.8991 16.6306 56.6346 15.6215L59.4296 18.1068Z'
-        fill='#292929'
-      />
-      <path
-        d='M59.7422 13.2297C59.7422 9.02528 62.9968 5.60571 67.4283 5.60571C71.8598 5.60571 75.1144 9.02528 75.1144 13.2297C75.1144 17.4341 71.8598 20.8536 67.4283 20.8536C62.9968 20.8349 59.7422 17.4341 59.7422 13.2297ZM71.3449 13.2297C71.3449 10.95 69.8003 9.06266 67.4283 9.06266C65.0563 9.04397 63.5117 10.95 63.5117 13.2297C63.5117 15.4907 65.0563 17.3967 67.4283 17.3967C69.8003 17.3967 71.3449 15.4907 71.3449 13.2297Z'
-        fill='#292929'
-      />
-      <path
-        d='M100.232 11.5482V20.4428H96.518V12.4638C96.518 9.94119 95.3412 8.85739 93.576 8.85739C91.921 8.85739 90.7442 9.67958 90.7442 12.4638V20.4428H87.0299V12.4638C87.0299 9.94119 85.8346 8.85739 84.0878 8.85739C82.4329 8.85739 80.9802 9.67958 80.9802 12.4638V20.4428H77.2659V5.8676H80.9802V7.88571C81.7525 6.31607 83.15 5.53125 85.3014 5.53125C87.3425 5.53125 89.0525 6.5403 89.9903 8.24074C90.9281 6.50293 92.3072 5.53125 94.8079 5.53125C97.8603 5.54994 100.232 7.86702 100.232 11.5482Z'
-        fill='#292929'
-      />
-    </svg>
-  )
-}

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

@@ -13,7 +13,6 @@ import {
   AsanaIcon,
   BrainIcon,
   BrowserUseIcon,
-  CalComIcon,
   CalendlyIcon,
   CirclebackIcon,
   ClayIcon,
@@ -142,7 +141,6 @@ export const blockTypeToIconMap: Record<string, IconComponent> = {
   arxiv: ArxivIcon,
   asana: AsanaIcon,
   browser_use: BrowserUseIcon,
-  calcom: CalComIcon,
   calendly: CalendlyIcon,
   circleback: CirclebackIcon,
   clay: ClayIcon,

apps/docs/content/docs/en/quick-reference/index.mdx

@@ -280,24 +280,14 @@ A quick lookup for everyday actions in the Sim workflow editor. For keyboard sho
       <td>Click clear button in Chat panel</td>
       <td><ActionImage src="/static/quick-reference/clear-chat.png" alt="Clear chat history" /></td>
     </tr>
-    <tr>
-      <td>Run from block</td>
-      <td>Hover block → Click play button, or right-click → **Run from block**</td>
-      <td><ActionImage src="/static/quick-reference/run-from-block.png" alt="Run from block" /></td>
-    </tr>
-    <tr>
-      <td>Run until block</td>
-      <td>Right-click block → **Run until block**</td>
-      <td><ActionImage src="/static/quick-reference/run-until-block.png" alt="Run until block" /></td>
-    </tr>
     <tr>
       <td>View execution logs</td>
       <td>Open terminal panel at bottom, or `Mod+L`</td>
       <td><ActionImage src="/static/quick-reference/terminal.png" alt="Execution logs terminal" /></td>
     </tr>
     <tr>
-      <td>Filter logs</td>
-      <td>Click filter icon in terminal → Filter by block or status</td>
+      <td>Filter logs by block or status</td>
+      <td>Click block filter in terminal or right-click log entry → **Filter by Block** or **Filter by Status**</td>
       <td><ActionImage src="/static/quick-reference/filter-block.png" alt="Filter logs by block" /></td>
     </tr>
     <tr>
@@ -345,11 +335,6 @@ A quick lookup for everyday actions in the Sim workflow editor. For keyboard sho
       <td>Access previous versions in Deploy tab → **Promote to live**</td>
       <td><ActionImage src="/static/quick-reference/promote-deployment.png" alt="Promote deployment to live" /></td>
     </tr>
-    <tr>
-      <td>Add version description</td>
-      <td>Deploy tab → Click description icon → Add or generate description</td>
-      <td><ActionVideo src="quick-reference/deployment-description.mp4" alt="Add deployment version description" /></td>
-    </tr>
     <tr>
       <td>Copy API endpoint</td>
       <td>Deploy tab → API → Copy API cURL</td>

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

@@ -1,515 +0,0 @@
----
-title: CalCom
-description: Manage Cal.com bookings, event types, schedules, and availability
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="calcom"
-  color="#FFFFFE"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Cal.com](https://cal.com/) is a flexible and open-source scheduling platform that makes it easy to manage appointments, bookings, event types, and team availabilities.
-
-With Cal.com, you can:
-
-- **Automate scheduling**: Allow users to view your available time slots and book meetings automatically, without back-and-forth emails.
-- **Manage events**: Create and customize event types, durations, and rules for one-on-one or group meetings.
-- **Integrate calendars**: Seamlessly connect with Google, Outlook, Apple, or other calendar providers to avoid double bookings.
-- **Handle attendees and guests**: Collect attendee information, manage guests, and send invitations or reminders.
-- **Control availability**: Define custom working hours, buffer times, and cancellation/rebooking rules.
-- **Power workflows**: Trigger custom actions via webhooks when a booking is created, cancelled, or rescheduled.
-
-In Sim, the Cal.com integration enables your agents to book meetings, check availabilities, manage event types, and automate scheduling tasks programmatically. This helps agents coordinate meetings, send bookings on behalf of users, check schedules, or respond to booking events—all without manual intervention. By connecting Sim with Cal.com, you unlock highly automated and intelligent scheduling workflows that can integrate seamlessly with your broader automation needs.
-{/* MANUAL-CONTENT-END */}
-
-
-## Usage Instructions
-
-Integrate Cal.com into your workflow. Create and manage bookings, event types, schedules, and check availability slots. Supports creating, listing, rescheduling, and canceling bookings, as well as managing event types and schedules. Can also trigger workflows based on Cal.com webhook events (booking created, cancelled, rescheduled). Connect your Cal.com account via OAuth.
-
-
-
-## Tools
-
-### `calcom_create_booking`
-
-Create a new booking on Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `eventTypeId` | number | Yes | The ID of the event type to book |
-| `start` | string | Yes | Start time in UTC ISO 8601 format \(e.g., 2024-01-15T09:00:00Z\) |
-| `attendee` | object | Yes | Attendee information object with name, email, timeZone, and optional phoneNumber |
-| `guests` | array | No | Array of guest email addresses |
-| `items` | string | No | Guest email address |
-| `lengthInMinutes` | number | No | Duration of the booking in minutes \(overrides event type default\) |
-| `metadata` | object | No | Custom metadata to attach to the booking |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Created booking details |
-
-### `calcom_get_booking`
-
-Get details of a specific booking by its UID
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `bookingUid` | string | Yes | Unique identifier \(UID\) of the booking |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Booking details |
-
-### `calcom_list_bookings`
-
-List all bookings with optional status filter
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `status` | string | No | Filter bookings by status: upcoming, recurring, past, cancelled, or unconfirmed |
-| `take` | number | No | Number of bookings to return \(pagination limit\) |
-| `skip` | number | No | Number of bookings to skip \(pagination offset\) |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | array | Array of bookings |
-
-### `calcom_cancel_booking`
-
-Cancel an existing booking
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `bookingUid` | string | Yes | Unique identifier \(UID\) of the booking to cancel |
-| `cancellationReason` | string | No | Reason for cancelling the booking |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Cancelled booking details |
-| ↳ `status` | string | Booking status \(should be cancelled\) |
-
-### `calcom_reschedule_booking`
-
-Reschedule an existing booking to a new time
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `bookingUid` | string | Yes | Unique identifier \(UID\) of the booking to reschedule |
-| `start` | string | Yes | New start time in UTC ISO 8601 format \(e.g., 2024-01-15T09:00:00Z\) |
-| `reschedulingReason` | string | No | Reason for rescheduling the booking |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Rescheduled booking details |
-| ↳ `uid` | string | Unique identifier for the new booking |
-| ↳ `start` | string | New start time in ISO 8601 format |
-| ↳ `end` | string | New end time in ISO 8601 format |
-
-### `calcom_confirm_booking`
-
-Confirm a pending booking that requires confirmation
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `bookingUid` | string | Yes | Unique identifier \(UID\) of the booking to confirm |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Confirmed booking details |
-| ↳ `status` | string | Booking status \(should be accepted/confirmed\) |
-
-### `calcom_decline_booking`
-
-Decline a pending booking request
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `bookingUid` | string | Yes | Unique identifier \(UID\) of the booking to decline |
-| `reason` | string | No | Reason for declining the booking |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Declined booking details |
-| ↳ `status` | string | Booking status \(should be cancelled/rejected\) |
-
-### `calcom_create_event_type`
-
-Create a new event type in Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `title` | string | Yes | Title of the event type |
-| `slug` | string | Yes | Unique slug for the event type URL |
-| `lengthInMinutes` | number | Yes | Duration of the event in minutes |
-| `description` | string | No | Description of the event type |
-| `slotInterval` | number | No | Interval between available booking slots in minutes |
-| `minimumBookingNotice` | number | No | Minimum notice required before booking in minutes |
-| `beforeEventBuffer` | number | No | Buffer time before the event in minutes |
-| `afterEventBuffer` | number | No | Buffer time after the event in minutes |
-| `scheduleId` | number | No | ID of the schedule to use for availability |
-| `disableGuests` | boolean | No | Whether to disable guests from being added to bookings |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Created event type details |
-| ↳ `id` | number | Event type ID |
-| ↳ `title` | string | Event type title |
-| ↳ `slug` | string | Event type slug |
-| ↳ `description` | string | Event type description |
-| ↳ `lengthInMinutes` | number | Duration in minutes |
-| ↳ `slotInterval` | number | Slot interval in minutes |
-| ↳ `minimumBookingNotice` | number | Minimum booking notice in minutes |
-| ↳ `beforeEventBuffer` | number | Buffer before event in minutes |
-| ↳ `afterEventBuffer` | number | Buffer after event in minutes |
-| ↳ `scheduleId` | number | Schedule ID |
-| ↳ `disableGuests` | boolean | Whether guests are disabled |
-| ↳ `createdAt` | string | ISO timestamp of creation |
-| ↳ `updatedAt` | string | ISO timestamp of last update |
-
-### `calcom_get_event_type`
-
-Get detailed information about a specific event type
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `eventTypeId` | number | Yes | Event type ID to retrieve |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Event type details |
-| ↳ `id` | number | Event type ID |
-| ↳ `title` | string | Event type title |
-| ↳ `slug` | string | Event type slug |
-| ↳ `description` | string | Event type description |
-| ↳ `lengthInMinutes` | number | Duration in minutes |
-| ↳ `slotInterval` | number | Slot interval in minutes |
-| ↳ `minimumBookingNotice` | number | Minimum booking notice in minutes |
-| ↳ `beforeEventBuffer` | number | Buffer before event in minutes |
-| ↳ `afterEventBuffer` | number | Buffer after event in minutes |
-| ↳ `scheduleId` | number | Schedule ID |
-| ↳ `disableGuests` | boolean | Whether guests are disabled |
-| ↳ `createdAt` | string | ISO timestamp of creation |
-| ↳ `updatedAt` | string | ISO timestamp of last update |
-
-### `calcom_list_event_types`
-
-Retrieve a list of all event types
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `sortCreatedAt` | string | No | Sort by creation date: "asc" or "desc" |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | array | Array of event types |
-|   ↳ `id` | number | Event type ID |
-|   ↳ `title` | string | Event type title |
-|   ↳ `slug` | string | Event type slug |
-|   ↳ `description` | string | Event type description |
-|   ↳ `lengthInMinutes` | number | Duration in minutes |
-|   ↳ `slotInterval` | number | Slot interval in minutes |
-|   ↳ `minimumBookingNotice` | number | Minimum booking notice in minutes |
-|   ↳ `beforeEventBuffer` | number | Buffer before event in minutes |
-|   ↳ `afterEventBuffer` | number | Buffer after event in minutes |
-|   ↳ `scheduleId` | number | Schedule ID |
-|   ↳ `disableGuests` | boolean | Whether guests are disabled |
-|   ↳ `createdAt` | string | ISO timestamp of creation |
-|   ↳ `updatedAt` | string | ISO timestamp of last update |
-
-### `calcom_update_event_type`
-
-Update an existing event type in Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `eventTypeId` | number | Yes | Event type ID to update |
-| `title` | string | No | Title of the event type |
-| `slug` | string | No | Unique slug for the event type URL |
-| `lengthInMinutes` | number | No | Duration of the event in minutes |
-| `description` | string | No | Description of the event type |
-| `slotInterval` | number | No | Interval between available booking slots in minutes |
-| `minimumBookingNotice` | number | No | Minimum notice required before booking in minutes |
-| `beforeEventBuffer` | number | No | Buffer time before the event in minutes |
-| `afterEventBuffer` | number | No | Buffer time after the event in minutes |
-| `scheduleId` | number | No | ID of the schedule to use for availability |
-| `disableGuests` | boolean | No | Whether to disable guests from being added to bookings |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Updated event type details |
-| ↳ `id` | number | Event type ID |
-| ↳ `title` | string | Event type title |
-| ↳ `slug` | string | Event type slug |
-| ↳ `description` | string | Event type description |
-| ↳ `lengthInMinutes` | number | Duration in minutes |
-| ↳ `slotInterval` | number | Slot interval in minutes |
-| ↳ `minimumBookingNotice` | number | Minimum booking notice in minutes |
-| ↳ `beforeEventBuffer` | number | Buffer before event in minutes |
-| ↳ `afterEventBuffer` | number | Buffer after event in minutes |
-| ↳ `scheduleId` | number | Schedule ID |
-| ↳ `disableGuests` | boolean | Whether guests are disabled |
-| ↳ `createdAt` | string | ISO timestamp of creation |
-| ↳ `updatedAt` | string | ISO timestamp of last update |
-
-### `calcom_delete_event_type`
-
-Delete an event type from Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `eventTypeId` | number | Yes | Event type ID to delete |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `deleted` | boolean | Whether the event type was successfully deleted |
-| `message` | string | Status message |
-
-### `calcom_create_schedule`
-
-Create a new availability schedule in Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `name` | string | Yes | Name of the schedule |
-| `timeZone` | string | Yes | Timezone for the schedule \(e.g., America/New_York\) |
-| `isDefault` | boolean | Yes | Whether this schedule should be the default |
-| `availability` | array | No | Availability intervals for the schedule |
-| `items` | object | No | Availability interval |
-| `properties` | array | No | Days of the week \(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday\) |
-| `days` | array | No | Days of the week \(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday\) |
-| `startTime` | string | No | Start time in HH:MM format |
-| `endTime` | string | No | End time in HH:MM format |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Created schedule data |
-| ↳ `id` | number | Unique identifier for the schedule |
-| ↳ `name` | string | Name of the schedule |
-| ↳ `timeZone` | string | Timezone of the schedule |
-| ↳ `isDefault` | boolean | Whether this is the default schedule |
-| ↳ `availability` | array | Availability intervals |
-|   ↳ `days` | array | Days of the week |
-|   ↳ `startTime` | string | Start time in HH:MM format |
-|   ↳ `endTime` | string | End time in HH:MM format |
-
-### `calcom_get_schedule`
-
-Get a specific schedule by ID from Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `scheduleId` | string | Yes | ID of the schedule to retrieve |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Schedule data |
-| ↳ `id` | number | Unique identifier for the schedule |
-| ↳ `name` | string | Name of the schedule |
-| ↳ `timeZone` | string | Timezone of the schedule |
-| ↳ `isDefault` | boolean | Whether this is the default schedule |
-| ↳ `availability` | array | Availability intervals |
-|   ↳ `days` | array | Days of the week |
-|   ↳ `startTime` | string | Start time in HH:MM format |
-|   ↳ `endTime` | string | End time in HH:MM format |
-
-### `calcom_list_schedules`
-
-List all availability schedules from Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | array | Array of schedule objects |
-|   ↳ `id` | number | Unique identifier for the schedule |
-|   ↳ `name` | string | Name of the schedule |
-|   ↳ `timeZone` | string | Timezone of the schedule |
-|   ↳ `isDefault` | boolean | Whether this is the default schedule |
-|   ↳ `availability` | array | Availability intervals |
-|   ↳ `days` | array | Days of the week |
-|   ↳ `startTime` | string | Start time in HH:MM format |
-|   ↳ `endTime` | string | End time in HH:MM format |
-
-### `calcom_update_schedule`
-
-Update an existing schedule in Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `scheduleId` | string | Yes | ID of the schedule to update |
-| `name` | string | No | New name for the schedule |
-| `timeZone` | string | No | New timezone for the schedule \(e.g., America/New_York\) |
-| `isDefault` | boolean | No | Whether this schedule should be the default |
-| `availability` | array | No | New availability intervals for the schedule |
-| `items` | object | No | Availability interval |
-| `properties` | array | No | Days of the week \(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday\) |
-| `days` | array | No | Days of the week \(Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday\) |
-| `startTime` | string | No | Start time in HH:MM format |
-| `endTime` | string | No | End time in HH:MM format |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Updated schedule data |
-| ↳ `id` | number | Unique identifier for the schedule |
-| ↳ `name` | string | Name of the schedule |
-| ↳ `timeZone` | string | Timezone of the schedule |
-| ↳ `isDefault` | boolean | Whether this is the default schedule |
-| ↳ `availability` | array | Availability intervals |
-|   ↳ `days` | array | Days of the week |
-|   ↳ `startTime` | string | Start time in HH:MM format |
-|   ↳ `endTime` | string | End time in HH:MM format |
-
-### `calcom_delete_schedule`
-
-Delete a schedule from Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `scheduleId` | string | Yes | ID of the schedule to delete |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Deleted schedule data |
-| ↳ `id` | number | Unique identifier of the deleted schedule |
-| ↳ `name` | string | Name of the deleted schedule |
-| ↳ `timeZone` | string | Timezone of the deleted schedule |
-| ↳ `isDefault` | boolean | Whether this was the default schedule |
-
-### `calcom_get_default_schedule`
-
-Get the default availability schedule from Cal.com
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Default schedule data |
-| ↳ `id` | number | Unique identifier for the schedule |
-| ↳ `name` | string | Name of the schedule |
-| ↳ `timeZone` | string | Timezone of the schedule |
-| ↳ `isDefault` | boolean | Whether this is the default schedule \(always true\) |
-| ↳ `availability` | array | Availability intervals |
-|   ↳ `days` | array | Days of the week |
-|   ↳ `startTime` | string | Start time in HH:MM format |
-|   ↳ `endTime` | string | End time in HH:MM format |
-
-### `calcom_get_slots`
-
-Get available booking slots for a Cal.com event type within a time range
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `start` | string | Yes | Start of time range in UTC ISO 8601 format \(e.g., 2024-01-15T00:00:00Z\) |
-| `end` | string | Yes | End of time range in UTC ISO 8601 format \(e.g., 2024-01-22T00:00:00Z\) |
-| `eventTypeId` | number | No | Event type ID for direct lookup |
-| `eventTypeSlug` | string | No | Event type slug \(requires username to be set\) |
-| `username` | string | No | Username for personal event types \(required when using eventTypeSlug\) |
-| `timeZone` | string | No | Timezone for returned slots \(defaults to UTC\) |
-| `duration` | number | No | Slot length in minutes |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `status` | string | Response status |
-| `data` | object | Slots data container |
-| ↳ `slots` | object | Available time slots grouped by date \(YYYY-MM-DD keys\) |
-
-

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

@@ -9,7 +9,6 @@
     "arxiv",
     "asana",
     "browser_use",
-    "calcom",
     "calendly",
     "circleback",
     "clay",

apps/sim/app/_styles/globals.css

@@ -14,7 +14,7 @@
   --panel-width: 320px; /* PANEL_WIDTH.DEFAULT */
   --toolbar-triggers-height: 300px; /* TOOLBAR_TRIGGERS_HEIGHT.DEFAULT */
   --editor-connections-height: 172px; /* EDITOR_CONNECTIONS_HEIGHT.DEFAULT */
-  --terminal-height: 206px; /* TERMINAL_HEIGHT.DEFAULT */
+  --terminal-height: 155px; /* TERMINAL_HEIGHT.DEFAULT */
 }
 
 .sidebar-container {

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

@@ -1,5 +1,5 @@
 import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
+import { copilotChats, workflow } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
@@ -16,6 +16,10 @@ import {
   createRequestTracker,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request-helpers'
+import {
+  handleToolCallEvent,
+  registerServerHandledTool,
+} from '@/lib/copilot/server-executor/stream-handler'
 import { getCredentialsServerTool } from '@/lib/copilot/tools/server/user/get-credentials'
 import type { CopilotProviderConfig } from '@/lib/copilot/types'
 import { env } from '@/lib/core/config/env'
@@ -36,11 +40,24 @@ const FileAttachmentSchema = z.object({
   size: z.number(),
 })
 
+/**
+ * Session context for headless mode.
+ * In headless mode, workflowId may not be known at start.
+ * The set_context tool can be used to establish context mid-conversation.
+ */
+const SessionContextSchema = z.object({
+  workflowId: z.string().optional(),
+  workspaceId: z.string().optional(),
+})
+
 const ChatMessageSchema = z.object({
   message: z.string().min(1, 'Message is required'),
   userMessageId: z.string().optional(), // ID from frontend for the user message
   chatId: z.string().optional(),
-  workflowId: z.string().min(1, 'Workflow ID is required'),
+  // workflowId is optional for headless mode - can be set via set_context tool
+  workflowId: z.string().optional(),
+  // Session context for headless mode - provides initial context that can be updated via set_context
+  sessionContext: SessionContextSchema.optional(),
   model: z.enum(COPILOT_MODEL_IDS).optional().default('claude-4.5-opus'),
   mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
   prefetch: z.boolean().optional(),
@@ -101,6 +118,7 @@ export async function POST(req: NextRequest) {
       userMessageId,
       chatId,
       workflowId,
+      sessionContext,
       model,
       mode,
       prefetch,
@@ -113,6 +131,43 @@ export async function POST(req: NextRequest) {
       contexts,
       commands,
     } = ChatMessageSchema.parse(body)
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Resolve execution context (workflowId, workspaceId)
+    // In client mode: workflowId comes from request, we look up workspaceId
+    // In headless mode: may start without workflowId, set via set_context tool
+    // ─────────────────────────────────────────────────────────────────────────
+    const resolvedWorkflowId = workflowId || sessionContext?.workflowId
+    let resolvedWorkspaceId = sessionContext?.workspaceId
+
+    // If we have a workflowId but no workspaceId, look it up once
+    if (resolvedWorkflowId && !resolvedWorkspaceId) {
+      try {
+        const [wf] = await db
+          .select({ workspaceId: workflow.workspaceId })
+          .from(workflow)
+          .where(eq(workflow.id, resolvedWorkflowId))
+          .limit(1)
+        resolvedWorkspaceId = wf?.workspaceId ?? undefined
+      } catch (error) {
+        logger.warn(`[${tracker.requestId}] Failed to lookup workspaceId for workflow`, {
+          workflowId: resolvedWorkflowId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
+
+    // Build execution context that will be passed to Go and used for tool execution
+    // Source is 'ui' since this route is called from the browser UI
+    const executionContext = {
+      userId: authenticatedUserId,
+      workflowId: resolvedWorkflowId,
+      workspaceId: resolvedWorkspaceId,
+      source: 'ui' as const,
+    }
+
+    logger.debug(`[${tracker.requestId}] Resolved execution context`, executionContext)
+
     // Ensure we have a consistent user message ID for this request
     const userMessageIdToUse = userMessageId || crypto.randomUUID()
     try {
@@ -427,7 +482,7 @@ export async function POST(req: NextRequest) {
 
     const requestPayload = {
       message: message, // Just send the current user message text
-      workflowId,
+      workflowId: resolvedWorkflowId,
       userId: authenticatedUserId,
       stream: stream,
       streamToolCalls: true,
@@ -435,6 +490,9 @@ export async function POST(req: NextRequest) {
       mode: transportMode,
       messageId: userMessageIdToUse,
       version: SIM_AGENT_VERSION,
+      // Execution context for Go to maintain and echo back in tool_call events
+      // This enables headless mode where context can be set dynamically via set_context tool
+      executionContext,
       ...(providerConfig ? { provider: providerConfig } : {}),
       ...(effectiveConversationId ? { conversationId: effectiveConversationId } : {}),
       ...(typeof prefetch === 'boolean' ? { prefetch: prefetch } : {}),
@@ -618,6 +676,40 @@ export async function POST(req: NextRequest) {
                           toolCalls.push(event.data)
                           if (event.data?.id) {
                             announcedToolCallIds.add(event.data.id)
+
+                            // Execute server-side tools automatically
+                            // This runs async and calls mark-complete when done
+                            // Use context from Go's event.data.executionContext if provided,
+                            // falling back to the initial resolved context
+                            const toolContext = {
+                              userId: authenticatedUserId,
+                              workflowId:
+                                event.data.executionContext?.workflowId || resolvedWorkflowId,
+                              workspaceId:
+                                event.data.executionContext?.workspaceId || resolvedWorkspaceId,
+                              chatId: actualChatId,
+                              source: 'ui' as const,
+                            }
+                            handleToolCallEvent(
+                              {
+                                id: event.data.id,
+                                name: event.data.name,
+                                arguments: event.data.arguments || {},
+                                partial: false,
+                              },
+                              toolContext
+                            ).then((handledServerSide) => {
+                              if (handledServerSide) {
+                                registerServerHandledTool(event.data.id, event.data.name)
+                                logger.info(
+                                  `[${tracker.requestId}] Tool will be executed server-side`,
+                                  {
+                                    toolCallId: event.data.id,
+                                    toolName: event.data.name,
+                                  }
+                                )
+                              }
+                            })
                           }
                         }
                         break

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

@@ -0,0 +1,189 @@
+/**
+ * POST /api/copilot/test
+ *
+ * Simple test endpoint for copilot without authentication.
+ * Pass just a query and optional userId to test headless mode.
+ *
+ * Request body:
+ * {
+ *   query: string,           // Required - the message to send
+ *   userId?: string,         // Optional - defaults to 'test-user'
+ *   workflowId?: string,     // Optional - workflow context
+ *   workspaceId?: string,    // Optional - workspace context
+ *   stream?: boolean,        // Optional - defaults to true
+ * }
+ */
+
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { SIM_AGENT_API_URL_DEFAULT, SIM_AGENT_VERSION } from '@/lib/copilot/constants'
+import {
+  handleToolCallEvent,
+  registerServerHandledTool,
+} from '@/lib/copilot/server-executor/stream-handler'
+import { env } from '@/lib/core/config/env'
+
+const logger = createLogger('CopilotTestAPI')
+
+const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
+
+const TestRequestSchema = z.object({
+  query: z.string().min(1, 'Query is required'),
+  userId: z.string().optional().default('test-user'),
+  workflowId: z.string().optional(),
+  workspaceId: z.string().optional(),
+  stream: z.boolean().optional().default(true),
+})
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json()
+    const { query, userId, workflowId, workspaceId, stream } = TestRequestSchema.parse(body)
+
+    logger.info('Test copilot request', { query, userId, workflowId, workspaceId, stream })
+
+    // Build execution context
+    // Source is 'headless' since this is a test/API endpoint without UI
+    const executionContext = {
+      userId,
+      workflowId,
+      workspaceId,
+      source: 'headless' as const,
+    }
+
+    // Build request payload for Go copilot
+    const requestPayload = {
+      message: query,
+      workflowId,
+      userId,
+      stream: stream,
+      streamToolCalls: true,
+      model: 'claude-sonnet-4-20250514',
+      mode: 'agent',
+      messageId: crypto.randomUUID(),
+      version: SIM_AGENT_VERSION,
+      executionContext,
+    }
+
+    logger.info('Sending to Go copilot', { url: `${SIM_AGENT_API_URL}/api/chat-completion-streaming` })
+
+    const simAgentResponse = await fetch(`${SIM_AGENT_API_URL}/api/chat-completion-streaming`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+      },
+      body: JSON.stringify(requestPayload),
+    })
+
+    if (!simAgentResponse.ok) {
+      const errorText = await simAgentResponse.text().catch(() => '')
+      logger.error('Go copilot error', { status: simAgentResponse.status, error: errorText })
+      return NextResponse.json(
+        { error: `Copilot error: ${simAgentResponse.statusText}`, details: errorText },
+        { status: simAgentResponse.status }
+      )
+    }
+
+    if (stream && simAgentResponse.body) {
+      // Create streaming response
+      const transformedStream = new ReadableStream({
+        async start(controller) {
+          const encoder = new TextEncoder()
+          const reader = simAgentResponse.body!.getReader()
+          const decoder = new TextDecoder()
+          let buffer = ''
+
+          try {
+            while (true) {
+              const { done, value } = await reader.read()
+              if (done) break
+
+              const chunk = decoder.decode(value, { stream: true })
+              buffer += chunk
+
+              const lines = buffer.split('\n')
+              buffer = lines.pop() || ''
+
+              for (const line of lines) {
+                if (line.trim() === '') continue
+
+                if (line.startsWith('data: ') && line.length > 6) {
+                  try {
+                    const jsonStr = line.slice(6)
+                    const event = JSON.parse(jsonStr)
+
+                    // Handle tool calls server-side
+                    if (event.type === 'tool_call' && !event.data?.partial && event.data?.id) {
+                      const toolContext = {
+                        userId,
+                        workflowId: event.data.executionContext?.workflowId || workflowId,
+                        workspaceId: event.data.executionContext?.workspaceId || workspaceId,
+                        chatId: undefined,
+                        source: 'headless' as const,
+                      }
+
+                      handleToolCallEvent(
+                        {
+                          id: event.data.id,
+                          name: event.data.name,
+                          arguments: event.data.arguments || {},
+                          partial: false,
+                        },
+                        toolContext
+                      ).then((handledServerSide) => {
+                        if (handledServerSide) {
+                          registerServerHandledTool(event.data.id, event.data.name)
+                          logger.info('Tool executed server-side', {
+                            toolCallId: event.data.id,
+                            toolName: event.data.name,
+                          })
+                        }
+                      })
+                    }
+                  } catch {
+                    // Ignore parse errors
+                  }
+                }
+
+                // Forward all events to client
+                controller.enqueue(encoder.encode(line + '\n'))
+              }
+            }
+
+            // Handle remaining buffer
+            if (buffer.trim()) {
+              controller.enqueue(encoder.encode(buffer + '\n'))
+            }
+          } catch (error) {
+            logger.error('Stream error', { error })
+          } finally {
+            controller.close()
+          }
+        },
+      })
+
+      return new Response(transformedStream, {
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+        },
+      })
+    } else {
+      // Non-streaming response
+      const text = await simAgentResponse.text()
+      return NextResponse.json({ response: text })
+    }
+  } catch (error) {
+    logger.error('Test endpoint error', { error })
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Invalid request', details: error.errors }, { status: 400 })
+    }
+    return NextResponse.json(
+      { error: 'Internal error', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    )
+  }
+}

apps/sim/app/api/copilot/tools/execution-state/[toolCallId]/route.ts

@@ -0,0 +1,64 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request-helpers'
+import { getToolExecutionState } from '@/lib/copilot/server-executor/stream-handler'
+
+const logger = createLogger('ToolExecutionStateAPI')
+
+/**
+ * GET /api/copilot/tools/execution-state/[toolCallId]
+ *
+ * Returns the execution state of a tool call.
+ * Useful for client reconnection scenarios.
+ */
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ toolCallId: string }> }
+) {
+  try {
+    const { userId, isAuthenticated } = await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !userId) {
+      return createUnauthorizedResponse()
+    }
+
+    const { toolCallId } = await params
+
+    if (!toolCallId) {
+      return NextResponse.json({ error: 'Tool call ID is required' }, { status: 400 })
+    }
+
+    const state = await getToolExecutionState(toolCallId)
+
+    if (!state) {
+      return NextResponse.json({ error: 'Tool call not found' }, { status: 404 })
+    }
+
+    // Verify the user owns this tool execution
+    if (state.userId !== userId) {
+      logger.warn("User attempted to access another user's tool execution", {
+        requestingUserId: userId,
+        ownerUserId: state.userId,
+        toolCallId,
+      })
+      return NextResponse.json({ error: 'Tool call not found' }, { status: 404 })
+    }
+
+    return NextResponse.json({
+      toolCallId: state.toolCallId,
+      toolName: state.toolName,
+      status: state.status,
+      startedAt: state.startedAt,
+      completedAt: state.completedAt,
+      result: state.result,
+      error: state.error,
+    })
+  } catch (error) {
+    logger.error('Error fetching tool execution state', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}

apps/sim/app/api/copilot/tools/execution-states/route.ts

@@ -0,0 +1,85 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createBadRequestResponse,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request-helpers'
+import { getToolExecutionState } from '@/lib/copilot/server-executor/stream-handler'
+
+const logger = createLogger('ToolExecutionStatesAPI')
+
+const RequestSchema = z.object({
+  toolCallIds: z.array(z.string()).min(1).max(50),
+})
+
+/**
+ * POST /api/copilot/tools/execution-states
+ *
+ * Returns the execution states of multiple tool calls at once.
+ * Useful for efficient reconnection scenarios.
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const { userId, isAuthenticated } = await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !userId) {
+      return createUnauthorizedResponse()
+    }
+
+    const body = await req.json()
+    const { toolCallIds } = RequestSchema.parse(body)
+
+    const states: Record<
+      string,
+      {
+        toolCallId: string
+        toolName: string
+        status: string
+        startedAt: number
+        completedAt?: number
+        result?: unknown
+        error?: string
+      } | null
+    > = {}
+
+    // Fetch all states in parallel
+    const results = await Promise.all(
+      toolCallIds.map(async (toolCallId) => {
+        const state = await getToolExecutionState(toolCallId)
+        // Filter out states that don't belong to this user
+        if (state && state.userId !== userId) {
+          return { toolCallId, state: null }
+        }
+        return { toolCallId, state }
+      })
+    )
+
+    for (const { toolCallId, state } of results) {
+      if (state) {
+        states[toolCallId] = {
+          toolCallId: state.toolCallId,
+          toolName: state.toolName,
+          status: state.status,
+          startedAt: state.startedAt,
+          completedAt: state.completedAt,
+          result: state.result,
+          error: state.error,
+        }
+      } else {
+        states[toolCallId] = null
+      }
+    }
+
+    return NextResponse.json({ states })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createBadRequestResponse('Invalid request body')
+    }
+
+    logger.error('Error fetching tool execution states', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}

apps/sim/app/api/copilot/tools/mark-complete/route.ts

@@ -9,20 +9,13 @@ import {
   createRequestTracker,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request-helpers'
+import { MarkCompletePayloadSchema } from '@/lib/copilot/tools/shared/schemas'
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotMarkToolCompleteAPI')
 
 const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
 
-const MarkCompleteSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  status: z.number().int(),
-  message: z.any().optional(),
-  data: z.any().optional(),
-})
-
 /**
  * POST /api/copilot/tools/mark-complete
  * Proxy to Sim Agent: POST /api/tools/mark-complete
@@ -46,7 +39,7 @@ export async function POST(req: NextRequest) {
       })
     } catch {}
 
-    const parsed = MarkCompleteSchema.parse(body)
+    const parsed = MarkCompletePayloadSchema.parse(body)
 
     const messagePreview = (() => {
       try {

apps/sim/app/api/copilot/tools/server-executed/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from 'next/server'
+import { SERVER_EXECUTED_TOOLS } from '@/lib/copilot/server-executor/registry'
+
+/**
+ * GET /api/copilot/tools/server-executed
+ *
+ * Returns the list of tools that are executed server-side.
+ * Clients can use this to avoid double-executing these tools.
+ */
+export async function GET() {
+  return NextResponse.json({
+    tools: SERVER_EXECUTED_TOOLS,
+  })
+}

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

@@ -344,7 +344,7 @@ describe('Schedule PUT API (Reactivate)', () => {
       expect(nextRunAt).toBeGreaterThan(beforeCall)
       expect(nextRunAt).toBeLessThanOrEqual(afterCall + 5 * 60 * 1000 + 1000)
       // Should align with 5-minute intervals (minute divisible by 5)
-      expect(new Date(nextRunAt).getUTCMinutes() % 5).toBe(0)
+      expect(new Date(nextRunAt).getMinutes() % 5).toBe(0)
     })
 
     it('calculates nextRunAt from daily cron expression', async () => {
@@ -572,7 +572,7 @@ describe('Schedule PUT API (Reactivate)', () => {
       expect(nextRunAt.getTime()).toBeGreaterThan(beforeCall)
       expect(nextRunAt.getTime()).toBeLessThanOrEqual(beforeCall + 10 * 60 * 1000 + 1000)
       // Should align with 10-minute intervals
-      expect(nextRunAt.getUTCMinutes() % 10).toBe(0)
+      expect(nextRunAt.getMinutes() % 10).toBe(0)
     })
 
     it('handles hourly schedules with timezone correctly', async () => {
@@ -598,8 +598,8 @@ describe('Schedule PUT API (Reactivate)', () => {
 
       // Should be a future date at minute 15
       expect(nextRunAt.getTime()).toBeGreaterThan(beforeCall)
-      expect(nextRunAt.getUTCMinutes()).toBe(15)
-      expect(nextRunAt.getUTCSeconds()).toBe(0)
+      expect(nextRunAt.getMinutes()).toBe(15)
+      expect(nextRunAt.getSeconds()).toBe(0)
     })
 
     it('handles custom cron expressions with complex patterns and timezone', async () => {

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

@@ -9,24 +9,13 @@ import { createErrorResponse, createSuccessResponse } from '@/app/api/workflows/
 
 const logger = createLogger('WorkflowDeploymentVersionAPI')
 
-const patchBodySchema = z
-  .object({
-    name: z
-      .string()
-      .trim()
-      .min(1, 'Name cannot be empty')
-      .max(100, 'Name must be 100 characters or less')
-      .optional(),
-    description: z
-      .string()
-      .trim()
-      .max(500, 'Description must be 500 characters or less')
-      .nullable()
-      .optional(),
-  })
-  .refine((data) => data.name !== undefined || data.description !== undefined, {
-    message: 'At least one of name or description must be provided',
-  })
+const patchBodySchema = z.object({
+  name: z
+    .string()
+    .trim()
+    .min(1, 'Name cannot be empty')
+    .max(100, 'Name must be 100 characters or less'),
+})
 
 export const dynamic = 'force-dynamic'
 export const runtime = 'nodejs'
@@ -99,46 +88,33 @@ export async function PATCH(
       return createErrorResponse(validation.error.errors[0]?.message || 'Invalid request body', 400)
     }
 
-    const { name, description } = validation.data
-
-    const updateData: { name?: string; description?: string | null } = {}
-    if (name !== undefined) {
-      updateData.name = name
-    }
-    if (description !== undefined) {
-      updateData.description = description
-    }
+    const { name } = validation.data
 
     const [updated] = await db
       .update(workflowDeploymentVersion)
-      .set(updateData)
+      .set({ name })
       .where(
         and(
           eq(workflowDeploymentVersion.workflowId, id),
           eq(workflowDeploymentVersion.version, versionNum)
         )
       )
-      .returning({
-        id: workflowDeploymentVersion.id,
-        name: workflowDeploymentVersion.name,
-        description: workflowDeploymentVersion.description,
-      })
+      .returning({ id: workflowDeploymentVersion.id, name: workflowDeploymentVersion.name })
 
     if (!updated) {
       return createErrorResponse('Deployment version not found', 404)
     }
 
-    logger.info(`[${requestId}] Updated deployment version ${version} for workflow ${id}`, {
-      name: updateData.name,
-      description: updateData.description,
-    })
+    logger.info(
+      `[${requestId}] Renamed deployment version ${version} for workflow ${id} to "${name}"`
+    )
 
-    return createSuccessResponse({ name: updated.name, description: updated.description })
+    return createSuccessResponse({ name: updated.name })
   } catch (error: any) {
     logger.error(
-      `[${requestId}] Error updating deployment version ${version} for workflow ${id}`,
+      `[${requestId}] Error renaming deployment version ${version} for workflow ${id}`,
       error
     )
-    return createErrorResponse(error.message || 'Failed to update deployment version', 500)
+    return createErrorResponse(error.message || 'Failed to rename deployment version', 500)
   }
 }

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

@@ -26,7 +26,6 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
         id: workflowDeploymentVersion.id,
         version: workflowDeploymentVersion.version,
         name: workflowDeploymentVersion.name,
-        description: workflowDeploymentVersion.description,
         isActive: workflowDeploymentVersion.isActive,
         createdAt: workflowDeploymentVersion.createdAt,
         createdBy: workflowDeploymentVersion.createdBy,

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

@@ -1,216 +0,0 @@
-import { db, workflow as workflowTable } from '@sim/db'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { type NextRequest, NextResponse } from 'next/server'
-import { v4 as uuidv4 } from 'uuid'
-import { z } from 'zod'
-import { checkHybridAuth } from '@/lib/auth/hybrid'
-import { generateRequestId } from '@/lib/core/utils/request'
-import { SSE_HEADERS } from '@/lib/core/utils/sse'
-import { markExecutionCancelled } from '@/lib/execution/cancellation'
-import { LoggingSession } from '@/lib/logs/execution/logging-session'
-import { executeWorkflowCore } from '@/lib/workflows/executor/execution-core'
-import { createSSECallbacks } from '@/lib/workflows/executor/execution-events'
-import { ExecutionSnapshot } from '@/executor/execution/snapshot'
-import type { ExecutionMetadata, SerializableExecutionState } from '@/executor/execution/types'
-import { hasExecutionResult } from '@/executor/utils/errors'
-
-const logger = createLogger('ExecuteFromBlockAPI')
-
-const ExecuteFromBlockSchema = z.object({
-  startBlockId: z.string().min(1, 'Start block ID is required'),
-  sourceSnapshot: z.object({
-    blockStates: z.record(z.any()),
-    executedBlocks: z.array(z.string()),
-    blockLogs: z.array(z.any()),
-    decisions: z.object({
-      router: z.record(z.string()),
-      condition: z.record(z.string()),
-    }),
-    completedLoops: z.array(z.string()),
-    loopExecutions: z.record(z.any()).optional(),
-    parallelExecutions: z.record(z.any()).optional(),
-    parallelBlockMapping: z.record(z.any()).optional(),
-    activeExecutionPath: z.array(z.string()),
-  }),
-  input: z.any().optional(),
-})
-
-export const runtime = 'nodejs'
-export const dynamic = 'force-dynamic'
-
-export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
-  const requestId = generateRequestId()
-  const { id: workflowId } = 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 userId = auth.userId
-
-    let body: unknown
-    try {
-      body = await req.json()
-    } catch {
-      return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 })
-    }
-
-    const validation = ExecuteFromBlockSchema.safeParse(body)
-    if (!validation.success) {
-      logger.warn(`[${requestId}] Invalid request body:`, validation.error.errors)
-      return NextResponse.json(
-        {
-          error: 'Invalid request body',
-          details: validation.error.errors.map((e) => ({
-            path: e.path.join('.'),
-            message: e.message,
-          })),
-        },
-        { status: 400 }
-      )
-    }
-
-    const { startBlockId, sourceSnapshot, input } = validation.data
-    const executionId = uuidv4()
-
-    const [workflowRecord] = await db
-      .select({ workspaceId: workflowTable.workspaceId, userId: workflowTable.userId })
-      .from(workflowTable)
-      .where(eq(workflowTable.id, workflowId))
-      .limit(1)
-
-    if (!workflowRecord?.workspaceId) {
-      return NextResponse.json({ error: 'Workflow not found or has no workspace' }, { status: 404 })
-    }
-
-    const workspaceId = workflowRecord.workspaceId
-    const workflowUserId = workflowRecord.userId
-
-    logger.info(`[${requestId}] Starting run-from-block execution`, {
-      workflowId,
-      startBlockId,
-      executedBlocksCount: sourceSnapshot.executedBlocks.length,
-    })
-
-    const loggingSession = new LoggingSession(workflowId, executionId, 'manual', requestId)
-    const abortController = new AbortController()
-    let isStreamClosed = false
-
-    const stream = new ReadableStream<Uint8Array>({
-      async start(controller) {
-        const { sendEvent, onBlockStart, onBlockComplete, onStream } = createSSECallbacks({
-          executionId,
-          workflowId,
-          controller,
-          isStreamClosed: () => isStreamClosed,
-          setStreamClosed: () => {
-            isStreamClosed = true
-          },
-        })
-
-        const metadata: ExecutionMetadata = {
-          requestId,
-          workflowId,
-          userId,
-          executionId,
-          triggerType: 'manual',
-          workspaceId,
-          workflowUserId,
-          useDraftState: true,
-          isClientSession: true,
-          startTime: new Date().toISOString(),
-        }
-
-        const snapshot = new ExecutionSnapshot(metadata, {}, input || {}, {})
-
-        try {
-          const startTime = new Date()
-
-          sendEvent({
-            type: 'execution:started',
-            timestamp: startTime.toISOString(),
-            executionId,
-            workflowId,
-            data: { startTime: startTime.toISOString() },
-          })
-
-          const result = await executeWorkflowCore({
-            snapshot,
-            loggingSession,
-            abortSignal: abortController.signal,
-            runFromBlock: {
-              startBlockId,
-              sourceSnapshot: sourceSnapshot as SerializableExecutionState,
-            },
-            callbacks: { onBlockStart, onBlockComplete, onStream },
-          })
-
-          if (result.status === 'cancelled') {
-            sendEvent({
-              type: 'execution:cancelled',
-              timestamp: new Date().toISOString(),
-              executionId,
-              workflowId,
-              data: { duration: result.metadata?.duration || 0 },
-            })
-          } else {
-            sendEvent({
-              type: 'execution:completed',
-              timestamp: new Date().toISOString(),
-              executionId,
-              workflowId,
-              data: {
-                success: result.success,
-                output: result.output,
-                duration: result.metadata?.duration || 0,
-                startTime: result.metadata?.startTime || startTime.toISOString(),
-                endTime: result.metadata?.endTime || new Date().toISOString(),
-              },
-            })
-          }
-        } catch (error: unknown) {
-          const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-          logger.error(`[${requestId}] Run-from-block execution failed: ${errorMessage}`)
-
-          const executionResult = hasExecutionResult(error) ? error.executionResult : undefined
-
-          sendEvent({
-            type: 'execution:error',
-            timestamp: new Date().toISOString(),
-            executionId,
-            workflowId,
-            data: {
-              error: executionResult?.error || errorMessage,
-              duration: executionResult?.metadata?.duration || 0,
-            },
-          })
-        } finally {
-          if (!isStreamClosed) {
-            try {
-              controller.enqueue(new TextEncoder().encode('data: [DONE]\n\n'))
-              controller.close()
-            } catch {}
-          }
-        }
-      },
-      cancel() {
-        isStreamClosed = true
-        abortController.abort()
-        markExecutionCancelled(executionId).catch(() => {})
-      },
-    })
-
-    return new NextResponse(stream, {
-      headers: { ...SSE_HEADERS, 'X-Execution-Id': executionId },
-    })
-  } catch (error: unknown) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-    logger.error(`[${requestId}] Failed to start run-from-block execution:`, error)
-    return NextResponse.json(
-      { error: errorMessage || 'Failed to start execution' },
-      { status: 500 }
-    )
-  }
-}

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

@@ -53,7 +53,6 @@ const ExecuteWorkflowSchema = z.object({
       parallels: z.record(z.any()).optional(),
     })
     .optional(),
-  stopAfterBlockId: z.string().optional(),
 })
 
 export const runtime = 'nodejs'
@@ -223,7 +222,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
       includeFileBase64,
       base64MaxBytes,
       workflowStateOverride,
-      stopAfterBlockId,
     } = validation.data
 
     // For API key and internal JWT auth, the entire body is the input (except for our control fields)
@@ -239,7 +237,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
               includeFileBase64,
               base64MaxBytes,
               workflowStateOverride,
-              stopAfterBlockId: _stopAfterBlockId,
               workflowId: _workflowId, // Also exclude workflowId used for internal JWT auth
               ...rest
             } = body
@@ -437,7 +434,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
           loggingSession,
           includeFileBase64,
           base64MaxBytes,
-          stopAfterBlockId,
         })
 
         const outputWithBase64 = includeFileBase64
@@ -726,7 +722,6 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
             abortSignal: abortController.signal,
             includeFileBase64,
             base64MaxBytes,
-            stopAfterBlockId,
           })
 
           if (result.status === 'paused') {

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

@@ -57,6 +57,40 @@ function useSetToggle() {
   )
 }
 
+/**
+ * Generates a unique key for a trace span
+ */
+function getSpanKey(span: TraceSpan): string {
+  if (span.id) {
+    return span.id
+  }
+  const name = span.name || 'span'
+  const start = span.startTime || 'unknown-start'
+  const end = span.endTime || 'unknown-end'
+  return `${name}|${start}|${end}`
+}
+
+/**
+ * Merges multiple arrays of trace span children, deduplicating by span key
+ */
+function mergeTraceSpanChildren(...groups: TraceSpan[][]): TraceSpan[] {
+  const merged: TraceSpan[] = []
+  const seen = new Set<string>()
+
+  groups.forEach((group) => {
+    group.forEach((child) => {
+      const key = getSpanKey(child)
+      if (seen.has(key)) {
+        return
+      }
+      seen.add(key)
+      merged.push(child)
+    })
+  })
+
+  return merged
+}
+
 /**
  * Parses a time value to milliseconds
  */
@@ -82,16 +116,34 @@ function hasErrorInTree(span: TraceSpan): boolean {
 
 /**
  * Normalizes and sorts trace spans recursively.
- * Deduplicates children and sorts by start time.
+ * Merges children from both span.children and span.output.childTraceSpans,
+ * deduplicates them, and sorts by start time.
  */
 function normalizeAndSortSpans(spans: TraceSpan[]): TraceSpan[] {
   return spans
     .map((span) => {
       const enrichedSpan: TraceSpan = { ...span }
 
-      // Process and deduplicate children
-      const children = Array.isArray(span.children) ? span.children : []
-      enrichedSpan.children = children.length > 0 ? normalizeAndSortSpans(children) : undefined
+      // Clean output by removing childTraceSpans after extracting
+      if (enrichedSpan.output && typeof enrichedSpan.output === 'object') {
+        enrichedSpan.output = { ...enrichedSpan.output }
+        if ('childTraceSpans' in enrichedSpan.output) {
+          const { childTraceSpans, ...cleanOutput } = enrichedSpan.output as {
+            childTraceSpans?: TraceSpan[]
+          } & Record<string, unknown>
+          enrichedSpan.output = cleanOutput
+        }
+      }
+
+      // Merge and deduplicate children from both sources
+      const directChildren = Array.isArray(span.children) ? span.children : []
+      const outputChildren = Array.isArray(span.output?.childTraceSpans)
+        ? (span.output!.childTraceSpans as TraceSpan[])
+        : []
+
+      const mergedChildren = mergeTraceSpanChildren(directChildren, outputChildren)
+      enrichedSpan.children =
+        mergedChildren.length > 0 ? normalizeAndSortSpans(mergedChildren) : undefined
 
       return enrichedSpan
     })
@@ -521,19 +573,7 @@ const TraceSpanNode = memo(function TraceSpanNode({
     return children.sort((a, b) => parseTime(a.startTime) - parseTime(b.startTime))
   }, [span, spanId, spanStartTime])
 
-  // Hide empty model timing segments for agents without tool calls
-  const filteredChildren = useMemo(() => {
-    const isAgent = span.type?.toLowerCase() === 'agent'
-    const hasToolCalls =
-      (span.toolCalls?.length ?? 0) > 0 || allChildren.some((c) => c.type?.toLowerCase() === 'tool')
-
-    if (isAgent && !hasToolCalls) {
-      return allChildren.filter((c) => c.type?.toLowerCase() !== 'model')
-    }
-    return allChildren
-  }, [allChildren, span.type, span.toolCalls])
-
-  const hasChildren = filteredChildren.length > 0
+  const hasChildren = allChildren.length > 0
   const isExpanded = isRootWorkflow || expandedNodes.has(spanId)
   const isToggleable = !isRootWorkflow
 
@@ -645,7 +685,7 @@ const TraceSpanNode = memo(function TraceSpanNode({
           {/* Nested Children */}
           {hasChildren && (
             <div className='flex min-w-0 flex-col gap-[2px] border-[var(--border)] border-l pl-[10px]'>
-              {filteredChildren.map((child, index) => (
+              {allChildren.map((child, index) => (
                 <div key={child.id || `${spanId}-child-${index}`} className='pl-[6px]'>
                   <TraceSpanNode
                     span={child}

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

@@ -18,7 +18,6 @@ import {
 import { ScrollArea } from '@/components/ui/scroll-area'
 import { BASE_EXECUTION_CHARGE } from '@/lib/billing/constants'
 import { cn } from '@/lib/core/utils/cn'
-import { filterHiddenOutputKeys } from '@/lib/logs/execution/trace-spans/trace-spans'
 import {
   ExecutionSnapshot,
   FileCards,
@@ -275,13 +274,16 @@ 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)
+  // Extract and clean the workflow final output (remove childTraceSpans for cleaner display)
   const workflowOutput = useMemo(() => {
     const executionData = log?.executionData as
       | { finalOutput?: Record<string, unknown> }
       | undefined
     if (!executionData?.finalOutput) return null
-    return filterHiddenOutputKeys(executionData.finalOutput) as Record<string, unknown>
+    const { childTraceSpans, ...cleanOutput } = executionData.finalOutput as {
+      childTraceSpans?: unknown
+    } & Record<string, unknown>
+    return cleanOutput
   }, [log?.executionData])
 
   useEffect(() => {

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

@@ -78,7 +78,7 @@ export default function Logs() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
-  const [isLive, setIsLive] = useState(true)
+  const [isLive, setIsLive] = useState(false)
   const [isVisuallyRefreshing, setIsVisuallyRefreshing] = useState(false)
   const [isExporting, setIsExporting] = useState(false)
   const isSearchOpenRef = useRef<boolean>(false)

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/action-bar/action-bar.tsx

@@ -1,13 +1,11 @@
 import { memo, useCallback } from 'react'
 import { ArrowLeftRight, ArrowUpDown, Circle, CircleOff, LogOut } from 'lucide-react'
-import { Button, Copy, PlayOutline, Tooltip, Trash2 } from '@/components/emcn'
+import { Button, Copy, Tooltip, Trash2 } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import { isInputDefinitionTrigger } from '@/lib/workflows/triggers/input-definition-triggers'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
-import { useWorkflowExecution } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks'
 import { validateTriggerPaste } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
-import { useExecutionStore } from '@/stores/execution'
 import { useNotificationStore } from '@/stores/notifications'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
@@ -51,7 +49,6 @@ export const ActionBar = memo(
       collaborativeBatchToggleBlockHandles,
     } = useCollaborativeWorkflow()
     const { setPendingSelection } = useWorkflowRegistry()
-    const { handleRunFromBlock } = useWorkflowExecution()
 
     const addNotification = useNotificationStore((s) => s.addNotification)
 
@@ -100,39 +97,12 @@ export const ActionBar = memo(
       )
     )
 
-    const { activeWorkflowId } = useWorkflowRegistry()
-    const { isExecuting, getLastExecutionSnapshot } = useExecutionStore()
     const userPermissions = useUserPermissionsContext()
-    const edges = useWorkflowStore((state) => state.edges)
 
     const isStartBlock = isInputDefinitionTrigger(blockType)
     const isResponseBlock = blockType === 'response'
     const isNoteBlock = blockType === 'note'
     const isSubflowBlock = blockType === 'loop' || blockType === 'parallel'
-    const isInsideSubflow = parentId && (parentType === 'loop' || parentType === 'parallel')
-
-    const snapshot = activeWorkflowId ? getLastExecutionSnapshot(activeWorkflowId) : null
-    const incomingEdges = edges.filter((edge) => edge.target === blockId)
-    const isTriggerBlock = incomingEdges.length === 0
-
-    // Check if each source block is either executed OR is a trigger block (triggers don't need prior execution)
-    const isSourceSatisfied = (sourceId: string) => {
-      if (snapshot?.executedBlocks.includes(sourceId)) return true
-      // Check if source is a trigger (has no incoming edges itself)
-      const sourceIncomingEdges = edges.filter((edge) => edge.target === sourceId)
-      return sourceIncomingEdges.length === 0
-    }
-
-    // Non-trigger blocks need a snapshot to exist (so upstream outputs are available)
-    const dependenciesSatisfied =
-      isTriggerBlock || (snapshot && incomingEdges.every((edge) => isSourceSatisfied(edge.source)))
-    const canRunFromBlock =
-      dependenciesSatisfied && !isNoteBlock && !isInsideSubflow && !isExecuting
-
-    const handleRunFromBlockClick = useCallback(() => {
-      if (!activeWorkflowId || !canRunFromBlock) return
-      handleRunFromBlock(blockId, activeWorkflowId)
-    }, [blockId, activeWorkflowId, canRunFromBlock, handleRunFromBlock])
 
     /**
      * Get appropriate tooltip message based on disabled state
@@ -158,35 +128,30 @@ export const ActionBar = memo(
           'dark:border-transparent dark:bg-[var(--surface-4)]'
         )}
       >
-        {!isNoteBlock && !isInsideSubflow && (
+        {!isNoteBlock && (
           <Tooltip.Root>
             <Tooltip.Trigger asChild>
               <Button
                 variant='ghost'
                 onClick={(e) => {
                   e.stopPropagation()
-                  if (canRunFromBlock && !disabled) {
-                    handleRunFromBlockClick()
+                  if (!disabled) {
+                    collaborativeBatchToggleBlockEnabled([blockId])
                   }
                 }}
                 className={ACTION_BUTTON_STYLES}
-                disabled={disabled || !canRunFromBlock}
+                disabled={disabled}
               >
-                <PlayOutline className={ICON_SIZE} />
+                {isEnabled ? <Circle className={ICON_SIZE} /> : <CircleOff className={ICON_SIZE} />}
               </Button>
             </Tooltip.Trigger>
             <Tooltip.Content side='top'>
-              {(() => {
-                if (disabled) return getTooltipMessage('Run from block')
-                if (isExecuting) return 'Execution in progress'
-                if (!dependenciesSatisfied) return 'Run upstream blocks first'
-                return 'Run from block'
-              })()}
+              {getTooltipMessage(isEnabled ? 'Disable Block' : 'Enable Block')}
             </Tooltip.Content>
           </Tooltip.Root>
         )}
 
-        {!isNoteBlock && (
+        {isSubflowBlock && (
           <Tooltip.Root>
             <Tooltip.Trigger asChild>
               <Button

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

@@ -40,16 +40,9 @@ export interface BlockMenuProps {
   onRemoveFromSubflow: () => void
   onOpenEditor: () => void
   onRename: () => void
-  onRunFromBlock?: () => void
-  onRunUntilBlock?: () => void
   hasClipboard?: boolean
   showRemoveFromSubflow?: boolean
-  /** Whether run from block is available (has snapshot, was executed, not inside subflow) */
-  canRunFromBlock?: boolean
   disableEdit?: boolean
-  isExecuting?: boolean
-  /** Whether the selected block is a trigger (has no incoming edges) */
-  isPositionalTrigger?: boolean
 }
 
 /**
@@ -72,14 +65,9 @@ export function BlockMenu({
   onRemoveFromSubflow,
   onOpenEditor,
   onRename,
-  onRunFromBlock,
-  onRunUntilBlock,
   hasClipboard = false,
   showRemoveFromSubflow = false,
-  canRunFromBlock = false,
   disableEdit = false,
-  isExecuting = false,
-  isPositionalTrigger = false,
 }: BlockMenuProps) {
   const isSingleBlock = selectedBlocks.length === 1
 
@@ -90,15 +78,10 @@ export function BlockMenu({
     (b) =>
       TriggerUtils.requiresSingleInstance(b.type) || TriggerUtils.isSingleInstanceBlockType(b.type)
   )
-  // A block is a trigger if it's explicitly a trigger type OR has no incoming edges (positional trigger)
-  const hasTriggerBlock =
-    selectedBlocks.some((b) => TriggerUtils.isTriggerBlock(b)) || isPositionalTrigger
+  const hasTriggerBlock = selectedBlocks.some((b) => TriggerUtils.isTriggerBlock(b))
   const allNoteBlocks = selectedBlocks.every((b) => b.type === 'note')
   const isSubflow =
     isSingleBlock && (selectedBlocks[0]?.type === 'loop' || selectedBlocks[0]?.type === 'parallel')
-  const isInsideSubflow =
-    isSingleBlock &&
-    (selectedBlocks[0]?.parentType === 'loop' || selectedBlocks[0]?.parentType === 'parallel')
 
   const canRemoveFromSubflow = showRemoveFromSubflow && !hasTriggerBlock
 
@@ -220,38 +203,6 @@ export function BlockMenu({
           </PopoverItem>
         )}
 
-        {/* Run from/until block - only for single non-note block, not inside subflows */}
-        {isSingleBlock && !allNoteBlocks && !isInsideSubflow && (
-          <>
-            <PopoverDivider />
-            <PopoverItem
-              disabled={!canRunFromBlock || isExecuting}
-              onClick={() => {
-                if (canRunFromBlock && !isExecuting) {
-                  onRunFromBlock?.()
-                  onClose()
-                }
-              }}
-            >
-              Run from block
-            </PopoverItem>
-            {/* Hide "Run until" for triggers - they're always at the start */}
-            {!hasTriggerBlock && (
-              <PopoverItem
-                disabled={isExecuting}
-                onClick={() => {
-                  if (!isExecuting) {
-                    onRunUntilBlock?.()
-                    onClose()
-                  }
-                }}
-              >
-                Run until block
-              </PopoverItem>
-            )}
-          </>
-        )}
-
         {/* Destructive action */}
         <PopoverDivider />
         <PopoverItem

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

@@ -1,170 +0,0 @@
-'use client'
-
-import { useCallback, useRef, useState } from 'react'
-import {
-  Button,
-  Modal,
-  ModalBody,
-  ModalContent,
-  ModalFooter,
-  ModalHeader,
-  Textarea,
-} from '@/components/emcn'
-import {
-  useGenerateVersionDescription,
-  useUpdateDeploymentVersion,
-} from '@/hooks/queries/deployments'
-
-interface VersionDescriptionModalProps {
-  open: boolean
-  onOpenChange: (open: boolean) => void
-  workflowId: string
-  version: number
-  versionName: string
-  currentDescription: string | null | undefined
-}
-
-export function VersionDescriptionModal({
-  open,
-  onOpenChange,
-  workflowId,
-  version,
-  versionName,
-  currentDescription,
-}: VersionDescriptionModalProps) {
-  const initialDescriptionRef = useRef(currentDescription || '')
-  const [description, setDescription] = useState(initialDescriptionRef.current)
-  const [showUnsavedChangesAlert, setShowUnsavedChangesAlert] = useState(false)
-
-  const updateMutation = useUpdateDeploymentVersion()
-  const generateMutation = useGenerateVersionDescription()
-
-  const hasChanges = description.trim() !== initialDescriptionRef.current.trim()
-  const isGenerating = generateMutation.isPending
-
-  const handleCloseAttempt = useCallback(() => {
-    if (updateMutation.isPending || isGenerating) {
-      return
-    }
-    if (hasChanges) {
-      setShowUnsavedChangesAlert(true)
-    } else {
-      onOpenChange(false)
-    }
-  }, [hasChanges, updateMutation.isPending, isGenerating, onOpenChange])
-
-  const handleDiscardChanges = useCallback(() => {
-    setShowUnsavedChangesAlert(false)
-    setDescription(initialDescriptionRef.current)
-    onOpenChange(false)
-  }, [onOpenChange])
-
-  const handleGenerateDescription = useCallback(() => {
-    generateMutation.mutate({
-      workflowId,
-      version,
-      onStreamChunk: (accumulated) => {
-        setDescription(accumulated)
-      },
-    })
-  }, [workflowId, version, generateMutation])
-
-  const handleSave = useCallback(() => {
-    if (!workflowId) return
-
-    updateMutation.mutate(
-      {
-        workflowId,
-        version,
-        description: description.trim() || null,
-      },
-      {
-        onSuccess: () => {
-          onOpenChange(false)
-        },
-      }
-    )
-  }, [workflowId, version, description, updateMutation, onOpenChange])
-
-  return (
-    <>
-      <Modal open={open} onOpenChange={(openState) => !openState && handleCloseAttempt()}>
-        <ModalContent className='max-w-[480px]'>
-          <ModalHeader>
-            <span>Version Description</span>
-          </ModalHeader>
-          <ModalBody className='space-y-[10px]'>
-            <div className='flex items-center justify-between'>
-              <p className='text-[12px] text-[var(--text-secondary)]'>
-                {currentDescription ? 'Edit the' : 'Add a'} description for{' '}
-                <span className='font-medium text-[var(--text-primary)]'>{versionName}</span>
-              </p>
-              <Button
-                variant='active'
-                className='-my-1 h-5 px-2 py-0 text-[11px]'
-                onClick={handleGenerateDescription}
-                disabled={isGenerating || updateMutation.isPending}
-              >
-                {isGenerating ? 'Generating...' : 'Generate'}
-              </Button>
-            </div>
-            <Textarea
-              placeholder='Describe the changes in this deployment version...'
-              className='min-h-[120px] resize-none'
-              value={description}
-              onChange={(e) => setDescription(e.target.value)}
-              maxLength={500}
-              disabled={isGenerating}
-            />
-            <div className='flex items-center justify-between'>
-              {(updateMutation.error || generateMutation.error) && (
-                <p className='text-[12px] text-[var(--text-error)]'>
-                  {updateMutation.error?.message || generateMutation.error?.message}
-                </p>
-              )}
-              {!updateMutation.error && !generateMutation.error && <div />}
-              <p className='text-[11px] text-[var(--text-tertiary)]'>{description.length}/500</p>
-            </div>
-          </ModalBody>
-          <ModalFooter>
-            <Button
-              variant='default'
-              onClick={handleCloseAttempt}
-              disabled={updateMutation.isPending || isGenerating}
-            >
-              Cancel
-            </Button>
-            <Button
-              variant='tertiary'
-              onClick={handleSave}
-              disabled={updateMutation.isPending || isGenerating || !hasChanges}
-            >
-              {updateMutation.isPending ? 'Saving...' : 'Save'}
-            </Button>
-          </ModalFooter>
-        </ModalContent>
-      </Modal>
-
-      <Modal open={showUnsavedChangesAlert} onOpenChange={setShowUnsavedChangesAlert}>
-        <ModalContent className='max-w-[400px]'>
-          <ModalHeader>
-            <span>Unsaved Changes</span>
-          </ModalHeader>
-          <ModalBody>
-            <p className='text-[14px] text-[var(--text-secondary)]'>
-              You have unsaved changes. Are you sure you want to discard them?
-            </p>
-          </ModalBody>
-          <ModalFooter>
-            <Button variant='default' onClick={() => setShowUnsavedChangesAlert(false)}>
-              Keep Editing
-            </Button>
-            <Button variant='destructive' onClick={handleDiscardChanges}>
-              Discard Changes
-            </Button>
-          </ModalFooter>
-        </ModalContent>
-      </Modal>
-    </>
-  )
-}

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

@@ -1,31 +1,26 @@
 'use client'
 
 import { useEffect, useRef, useState } from 'react'
+import { createLogger } from '@sim/logger'
 import clsx from 'clsx'
-import { FileText, MoreVertical, Pencil, RotateCcw, SendToBack } from 'lucide-react'
-import {
-  Button,
-  Popover,
-  PopoverContent,
-  PopoverItem,
-  PopoverTrigger,
-  Tooltip,
-} from '@/components/emcn'
+import { MoreVertical, Pencil, RotateCcw, SendToBack } from 'lucide-react'
+import { Button, Popover, PopoverContent, PopoverItem, PopoverTrigger } from '@/components/emcn'
 import { Skeleton } from '@/components/ui'
-import { formatDateTime } from '@/lib/core/utils/formatting'
 import type { WorkflowDeploymentVersionResponse } from '@/lib/workflows/persistence/utils'
-import { useUpdateDeploymentVersion } from '@/hooks/queries/deployments'
-import { VersionDescriptionModal } from './version-description-modal'
 
+const logger = createLogger('Versions')
+
+/** Shared styling constants aligned with terminal component */
 const HEADER_TEXT_CLASS = 'font-medium text-[var(--text-tertiary)] text-[12px]'
 const ROW_TEXT_CLASS = 'font-medium text-[var(--text-primary)] text-[12px]'
 const COLUMN_BASE_CLASS = 'flex-shrink-0'
 
+/** Column width configuration */
 const COLUMN_WIDTHS = {
   VERSION: 'w-[180px]',
   DEPLOYED_BY: 'w-[140px]',
   TIMESTAMP: 'flex-1',
-  ACTIONS: 'w-[56px]',
+  ACTIONS: 'w-[32px]',
 } as const
 
 interface VersionsProps {
@@ -36,6 +31,34 @@ interface VersionsProps {
   onSelectVersion: (version: number | null) => void
   onPromoteToLive: (version: number) => void
   onLoadDeployment: (version: number) => void
+  fetchVersions: () => Promise<void>
+}
+
+/**
+ * Formats a timestamp into a readable string.
+ * @param value - The date string or Date object to format
+ * @returns Formatted string like "8:36 PM PT on Oct 11, 2025"
+ */
+const formatDate = (value: string | Date): string => {
+  const date = value instanceof Date ? value : new Date(value)
+  if (Number.isNaN(date.getTime())) {
+    return '-'
+  }
+
+  const timePart = date.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+    timeZoneName: 'short',
+  })
+
+  const datePart = date.toLocaleDateString('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  })
+
+  return `${timePart} on ${datePart}`
 }
 
 /**
@@ -50,15 +73,14 @@ export function Versions({
   onSelectVersion,
   onPromoteToLive,
   onLoadDeployment,
+  fetchVersions,
 }: VersionsProps) {
   const [editingVersion, setEditingVersion] = useState<number | null>(null)
   const [editValue, setEditValue] = useState('')
+  const [isRenaming, setIsRenaming] = useState(false)
   const [openDropdown, setOpenDropdown] = useState<number | null>(null)
-  const [descriptionModalVersion, setDescriptionModalVersion] = useState<number | null>(null)
   const inputRef = useRef<HTMLInputElement>(null)
 
-  const renameMutation = useUpdateDeploymentVersion()
-
   useEffect(() => {
     if (editingVersion !== null && inputRef.current) {
       inputRef.current.focus()
@@ -72,8 +94,7 @@ export function Versions({
     setEditValue(currentName || `v${version}`)
   }
 
-  const handleSaveRename = (version: number) => {
-    if (renameMutation.isPending) return
+  const handleSaveRename = async (version: number) => {
     if (!workflowId || !editValue.trim()) {
       setEditingVersion(null)
       return
@@ -87,21 +108,25 @@ export function Versions({
       return
     }
 
-    renameMutation.mutate(
-      {
-        workflowId,
-        version,
-        name: editValue.trim(),
-      },
-      {
-        onSuccess: () => {
-          setEditingVersion(null)
-        },
-        onError: () => {
-          // Keep editing state open on error so user can retry
-        },
+    setIsRenaming(true)
+    try {
+      const res = await fetch(`/api/workflows/${workflowId}/deployments/${version}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: editValue.trim() }),
+      })
+
+      if (res.ok) {
+        await fetchVersions()
+        setEditingVersion(null)
+      } else {
+        logger.error('Failed to rename version')
       }
-    )
+    } catch (error) {
+      logger.error('Error renaming version:', error)
+    } finally {
+      setIsRenaming(false)
+    }
   }
 
   const handleCancelRename = () => {
@@ -124,16 +149,6 @@ export function Versions({
     onLoadDeployment(version)
   }
 
-  const handleOpenDescriptionModal = (version: number) => {
-    setOpenDropdown(null)
-    setDescriptionModalVersion(version)
-  }
-
-  const descriptionModalVersionData =
-    descriptionModalVersion !== null
-      ? versions.find((v) => v.version === descriptionModalVersion)
-      : null
-
   if (versionsLoading && versions.length === 0) {
     return (
       <div className='overflow-hidden rounded-[4px] border border-[var(--border)]'>
@@ -164,14 +179,7 @@ export function Versions({
               <div className={clsx(COLUMN_WIDTHS.TIMESTAMP, 'min-w-0')}>
                 <Skeleton className='h-[12px] w-[160px]' />
               </div>
-              <div
-                className={clsx(
-                  COLUMN_WIDTHS.ACTIONS,
-                  COLUMN_BASE_CLASS,
-                  'flex justify-end gap-[2px]'
-                )}
-              >
-                <Skeleton className='h-[20px] w-[20px] rounded-[4px]' />
+              <div className={clsx(COLUMN_WIDTHS.ACTIONS, COLUMN_BASE_CLASS, 'flex justify-end')}>
                 <Skeleton className='h-[20px] w-[20px] rounded-[4px]' />
               </div>
             </div>
@@ -249,7 +257,7 @@ export function Versions({
                         'text-[var(--text-primary)] focus:outline-none focus:ring-0'
                       )}
                       maxLength={100}
-                      disabled={renameMutation.isPending}
+                      disabled={isRenaming}
                       autoComplete='off'
                       autoCorrect='off'
                       autoCapitalize='off'
@@ -281,40 +289,14 @@ export function Versions({
                 <span
                   className={clsx('block truncate text-[var(--text-tertiary)]', ROW_TEXT_CLASS)}
                 >
-                  {formatDateTime(new Date(v.createdAt))}
+                  {formatDate(v.createdAt)}
                 </span>
               </div>
 
               <div
-                className={clsx(
-                  COLUMN_WIDTHS.ACTIONS,
-                  COLUMN_BASE_CLASS,
-                  'flex items-center justify-end gap-[2px]'
-                )}
+                className={clsx(COLUMN_WIDTHS.ACTIONS, COLUMN_BASE_CLASS, 'flex justify-end')}
                 onClick={(e) => e.stopPropagation()}
               >
-                <Tooltip.Root>
-                  <Tooltip.Trigger asChild>
-                    <Button
-                      variant='ghost'
-                      className={clsx(
-                        '!p-1',
-                        !v.description &&
-                          'text-[var(--text-quaternary)] hover:text-[var(--text-tertiary)]'
-                      )}
-                      onClick={() => handleOpenDescriptionModal(v.version)}
-                    >
-                      <FileText className='h-3.5 w-3.5' />
-                    </Button>
-                  </Tooltip.Trigger>
-                  <Tooltip.Content side='top' className='max-w-[240px]'>
-                    {v.description ? (
-                      <p className='line-clamp-3 text-[12px]'>{v.description}</p>
-                    ) : (
-                      <p className='text-[12px]'>Add description</p>
-                    )}
-                  </Tooltip.Content>
-                </Tooltip.Root>
                 <Popover
                   open={openDropdown === v.version}
                   onOpenChange={(open) => setOpenDropdown(open ? v.version : null)}
@@ -329,10 +311,6 @@ export function Versions({
                       <Pencil className='h-3 w-3' />
                       <span>Rename</span>
                     </PopoverItem>
-                    <PopoverItem onClick={() => handleOpenDescriptionModal(v.version)}>
-                      <FileText className='h-3 w-3' />
-                      <span>{v.description ? 'Edit description' : 'Add description'}</span>
-                    </PopoverItem>
                     {!v.isActive && (
                       <PopoverItem onClick={() => handlePromote(v.version)}>
                         <RotateCcw className='h-3 w-3' />
@@ -350,20 +328,6 @@ export function Versions({
           )
         })}
       </div>
-
-      {workflowId && descriptionModalVersionData && (
-        <VersionDescriptionModal
-          key={descriptionModalVersionData.version}
-          open={descriptionModalVersion !== null}
-          onOpenChange={(open) => !open && setDescriptionModalVersion(null)}
-          workflowId={workflowId}
-          version={descriptionModalVersionData.version}
-          versionName={
-            descriptionModalVersionData.name || `v${descriptionModalVersionData.version}`
-          }
-          currentDescription={descriptionModalVersionData.description}
-        />
-      )}
     </div>
   )
 }

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

@@ -32,6 +32,7 @@ interface GeneralDeployProps {
   versionsLoading: boolean
   onPromoteToLive: (version: number) => Promise<void>
   onLoadDeploymentComplete: () => void
+  fetchVersions: () => Promise<void>
 }
 
 type PreviewMode = 'active' | 'selected'
@@ -47,6 +48,7 @@ export function GeneralDeploy({
   versionsLoading,
   onPromoteToLive,
   onLoadDeploymentComplete,
+  fetchVersions,
 }: GeneralDeployProps) {
   const [selectedVersion, setSelectedVersion] = useState<number | null>(null)
   const [previewMode, setPreviewMode] = useState<PreviewMode>('active')
@@ -227,6 +229,7 @@ export function GeneralDeploy({
             onSelectVersion={handleSelectVersion}
             onPromoteToLive={handlePromoteToLive}
             onLoadDeployment={handleLoadDeployment}
+            fetchVersions={fetchVersions}
           />
         </div>
       </div>

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

@@ -135,9 +135,11 @@ export function DeployModal({
     refetch: refetchDeploymentInfo,
   } = useDeploymentInfo(workflowId, { enabled: open && isDeployed })
 
-  const { data: versionsData, isLoading: versionsLoading } = useDeploymentVersions(workflowId, {
-    enabled: open,
-  })
+  const {
+    data: versionsData,
+    isLoading: versionsLoading,
+    refetch: refetchVersions,
+  } = useDeploymentVersions(workflowId, { enabled: open })
 
   const {
     isLoading: isLoadingChat,
@@ -448,6 +450,10 @@ export function DeployModal({
     deleteTrigger?.click()
   }, [])
 
+  const handleFetchVersions = useCallback(async () => {
+    await refetchVersions()
+  }, [refetchVersions])
+
   const isSubmitting = deployMutation.isPending
   const isUndeploying = undeployMutation.isPending
 
@@ -506,6 +512,7 @@ export function DeployModal({
                   versionsLoading={versionsLoading}
                   onPromoteToLive={handlePromoteToLive}
                   onLoadDeploymentComplete={handleCloseModal}
+                  fetchVersions={handleFetchVersions}
                 />
               </ModalTabsContent>
 

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

@@ -3,9 +3,8 @@
 import { useCallback, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import clsx from 'clsx'
-import { RepeatIcon, SplitIcon } from 'lucide-react'
+import { ChevronDown, RepeatIcon, SplitIcon } from 'lucide-react'
 import { useShallow } from 'zustand/react/shallow'
-import { ChevronDown } from '@/components/emcn'
 import {
   FieldItem,
   type SchemaField,
@@ -116,8 +115,9 @@ function ConnectionItem({
         {hasFields && (
           <ChevronDown
             className={clsx(
-              'h-[8px] w-[8px] flex-shrink-0 text-[var(--text-tertiary)] transition-transform duration-100 group-hover:text-[var(--text-primary)]',
-              !isExpanded && '-rotate-90'
+              'h-3.5 w-3.5 flex-shrink-0 transition-transform duration-100',
+              'text-[var(--text-secondary)] group-hover:text-[var(--text-primary)]',
+              isExpanded && 'rotate-180'
             )}
           />
         )}

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

@@ -1,5 +1,5 @@
 import { memo, useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react'
-import { Wand2 } from 'lucide-react'
+import { Check, Copy, Wand2 } from 'lucide-react'
 import { useReactFlow } from 'reactflow'
 import { Input } from '@/components/emcn'
 import { Button } from '@/components/ui/button'
@@ -40,6 +40,8 @@ interface ShortInputProps {
   disabled?: boolean
   /** Whether the input is read-only */
   readOnly?: boolean
+  /** Whether to show a copy button */
+  showCopyButton?: boolean
   /** Whether to use webhook URL as value */
   useWebhookUrl?: boolean
   /** Ref to expose wand control handlers to parent */
@@ -57,6 +59,7 @@ interface ShortInputProps {
  * - Handles drag-and-drop for connections and variable references
  * - Provides environment variable and tag autocomplete
  * - Password masking with reveal on focus
+ * - Copy to clipboard functionality
  * - Integrates with ReactFlow for zoom control
  */
 export const ShortInput = memo(function ShortInput({
@@ -71,12 +74,14 @@ export const ShortInput = memo(function ShortInput({
   previewValue,
   disabled = false,
   readOnly = false,
+  showCopyButton = false,
   useWebhookUrl = false,
   wandControlRef,
   hideInternalWand = false,
 }: ShortInputProps) {
   const [localContent, setLocalContent] = useState<string>('')
   const [isFocused, setIsFocused] = useState(false)
+  const [copied, setCopied] = useState(false)
   const persistSubBlockValueRef = useRef<(value: string) => void>(() => {})
 
   const justPastedRef = useRef(false)
@@ -273,6 +278,18 @@ export const ShortInput = memo(function ShortInput({
     [reactFlowInstance]
   )
 
+  /**
+   * Handles copying the value to the clipboard.
+   */
+  const handleCopy = useCallback(() => {
+    const textToCopy = useWebhookUrl ? webhookManagement?.webhookUrl : value?.toString()
+    if (textToCopy) {
+      navigator.clipboard.writeText(textToCopy)
+      setCopied(true)
+      setTimeout(() => setCopied(false), 2000)
+    }
+  }, [useWebhookUrl, webhookManagement?.webhookUrl, value])
+
   const handleBlur = useCallback(() => {
     setIsFocused(false)
   }, [])
@@ -349,7 +366,10 @@ export const ShortInput = memo(function ShortInput({
               <>
                 <Input
                   ref={ref as React.RefObject<HTMLInputElement>}
-                  className='allow-scroll w-full overflow-auto text-transparent caret-foreground [-ms-overflow-style:none] [scrollbar-width:none] placeholder:text-muted-foreground/50 [&::-webkit-scrollbar]:hidden'
+                  className={cn(
+                    'allow-scroll w-full overflow-auto text-transparent caret-foreground [-ms-overflow-style:none] [scrollbar-width:none] placeholder:text-muted-foreground/50 [&::-webkit-scrollbar]:hidden',
+                    showCopyButton && 'pr-14'
+                  )}
                   readOnly={readOnly}
                   placeholder={placeholder ?? ''}
                   type='text'
@@ -372,7 +392,8 @@ export const ShortInput = memo(function ShortInput({
                 <div
                   ref={overlayRef}
                   className={cn(
-                    'pointer-events-none absolute inset-0 flex items-center overflow-x-auto bg-transparent px-[8px] py-[6px] pr-3 font-medium font-sans text-foreground text-sm [-ms-overflow-style:none] [scrollbar-width:none] [&::-webkit-scrollbar]:hidden',
+                    'pointer-events-none absolute inset-0 flex items-center overflow-x-auto bg-transparent px-[8px] py-[6px] font-medium font-sans text-foreground text-sm [-ms-overflow-style:none] [scrollbar-width:none] [&::-webkit-scrollbar]:hidden',
+                    showCopyButton ? 'pr-14' : 'pr-3',
                     (isPreview || disabled) && 'opacity-50'
                   )}
                 >
@@ -383,6 +404,27 @@ export const ShortInput = memo(function ShortInput({
           }}
         </SubBlockInputController>
 
+        {/* Copy Button */}
+        {showCopyButton && value && (
+          <div className='pointer-events-none absolute top-0 right-0 bottom-0 z-10 flex w-14 items-center justify-end pr-2 opacity-0 transition-opacity group-hover:opacity-100'>
+            <Button
+              type='button'
+              variant='ghost'
+              size='icon'
+              onClick={handleCopy}
+              disabled={!value}
+              className='pointer-events-auto h-6 w-6 p-0'
+              aria-label='Copy value'
+            >
+              {copied ? (
+                <Check className='h-3.5 w-3.5 text-green-500' />
+              ) : (
+                <Copy className='h-3.5 w-3.5 text-muted-foreground' />
+              )}
+            </Button>
+          </div>
+        )}
+
         {/* Wand Button - only show if not hidden by parent */}
         {isWandEnabled && !isPreview && !wandHook.isStreaming && !hideInternalWand && (
           <div className='-translate-y-1/2 absolute top-1/2 right-3 z-10 flex items-center gap-1 opacity-0 transition-opacity group-hover:opacity-100'>

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/components/keyboard-navigation-handler.tsx

@@ -14,8 +14,6 @@ interface KeyboardNavigationHandlerProps {
   flatTagList: Array<{ tag: string; group?: BlockTagGroup }>
   nestedBlockTagGroups: NestedBlockTagGroup[]
   handleTagSelect: (tag: string, group?: BlockTagGroup) => void
-  /** Called when entering a folder from root level via keyboard navigation */
-  onFolderEnter?: () => void
 }
 
 /**
@@ -109,7 +107,6 @@ export const KeyboardNavigationHandler: React.FC<KeyboardNavigationHandlerProps>
   flatTagList,
   nestedBlockTagGroups,
   handleTagSelect,
-  onFolderEnter,
 }) => {
   const { openFolder, closeFolder, isInFolder, currentFolder, setKeyboardNav } = usePopoverContext()
   const nestedNav = useNestedNavigation()
@@ -254,7 +251,7 @@ export const KeyboardNavigationHandler: React.FC<KeyboardNavigationHandlerProps>
             } else if (currentVisibleIndex < visibleIndices.length - 1) {
               newIndex = visibleIndices[currentVisibleIndex + 1]
             } else {
-              newIndex = selectedIndex
+              newIndex = visibleIndices[0]
             }
             setSelectedIndex(newIndex)
             scrollIntoView()
@@ -272,7 +269,7 @@ export const KeyboardNavigationHandler: React.FC<KeyboardNavigationHandlerProps>
             } else if (currentVisibleIndex > 0) {
               newIndex = visibleIndices[currentVisibleIndex - 1]
             } else {
-              newIndex = selectedIndex
+              newIndex = visibleIndices[visibleIndices.length - 1]
             }
             setSelectedIndex(newIndex)
             scrollIntoView()
@@ -298,7 +295,6 @@ export const KeyboardNavigationHandler: React.FC<KeyboardNavigationHandlerProps>
                 currentFolderInfo.parentTag,
                 currentFolderInfo.group
               )
-              onFolderEnter?.()
             }
           }
           break
@@ -350,7 +346,6 @@ export const KeyboardNavigationHandler: React.FC<KeyboardNavigationHandlerProps>
     handleTagSelect,
     nestedNav,
     setKeyboardNav,
-    onFolderEnter,
   ])
 
   return null

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

@@ -444,12 +444,10 @@ interface NestedTagRendererProps {
   nestedTag: NestedTag
   group: NestedBlockTagGroup
   flatTagList: Array<{ tag: string; group?: BlockTagGroup }>
-  /** Map from tag string to index for O(1) lookups */
-  flatTagIndexMap: Map<string, number>
   selectedIndex: number
   setSelectedIndex: (index: number) => void
   handleTagSelect: (tag: string, blockGroup?: BlockTagGroup) => void
-  itemRefs: React.RefObject<Map<string, HTMLElement>>
+  itemRefs: React.RefObject<Map<number, HTMLElement>>
   blocks: Record<string, BlockState>
   getMergedSubBlocks: (blockId: string) => Record<string, any>
 }
@@ -471,7 +469,6 @@ interface FolderContentsProps extends NestedTagRendererProps {
 const FolderContentsInner: React.FC<FolderContentsProps> = ({
   group,
   flatTagList,
-  flatTagIndexMap,
   selectedIndex,
   setSelectedIndex,
   handleTagSelect,
@@ -486,7 +483,7 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
   const currentNestedTag = nestedPath.length > 0 ? nestedPath[nestedPath.length - 1] : nestedTag
 
   const parentTagIndex = currentNestedTag.parentTag
-    ? (flatTagIndexMap.get(currentNestedTag.parentTag) ?? -1)
+    ? flatTagList.findIndex((item) => item.tag === currentNestedTag.parentTag)
     : -1
 
   return (
@@ -496,6 +493,7 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
         <PopoverItem
           active={parentTagIndex === selectedIndex && parentTagIndex >= 0}
           onMouseEnter={() => {
+            // Skip selection update during keyboard navigation to prevent scroll-triggered selection changes
             if (isKeyboardNav) return
             setKeyboardNav(false)
             if (parentTagIndex >= 0) setSelectedIndex(parentTagIndex)
@@ -506,8 +504,8 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
             handleTagSelect(currentNestedTag.parentTag!, group)
           }}
           ref={(el) => {
-            if (el && currentNestedTag.parentTag) {
-              itemRefs.current?.set(currentNestedTag.parentTag, el)
+            if (el && parentTagIndex >= 0) {
+              itemRefs.current?.set(parentTagIndex, el)
             }
           }}
         >
@@ -517,7 +515,7 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
 
       {/* Render leaf children as PopoverItems */}
       {currentNestedTag.children?.map((child) => {
-        const childGlobalIndex = flatTagIndexMap.get(child.fullTag) ?? -1
+        const childGlobalIndex = flatTagList.findIndex((item) => item.tag === child.fullTag)
 
         const tagParts = child.fullTag.split('.')
         const outputPath = tagParts.slice(1).join('.')
@@ -552,8 +550,8 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
               handleTagSelect(child.fullTag, group)
             }}
             ref={(el) => {
-              if (el) {
-                itemRefs.current?.set(child.fullTag, el)
+              if (el && childGlobalIndex >= 0) {
+                itemRefs.current?.set(childGlobalIndex, el)
               }
             }}
           >
@@ -570,7 +568,7 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
       {/* Render nested children as clickable folder items */}
       {currentNestedTag.nestedChildren?.map((nestedChild) => {
         const parentGlobalIndex = nestedChild.parentTag
-          ? (flatTagIndexMap.get(nestedChild.parentTag) ?? -1)
+          ? flatTagList.findIndex((item) => item.tag === nestedChild.parentTag)
           : -1
 
         return (
@@ -585,11 +583,12 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
             onMouseDown={(e) => {
               e.preventDefault()
               e.stopPropagation()
+              // Navigate into the subfolder on click
               onNavigateIn(nestedChild)
             }}
             ref={(el) => {
-              if (el && nestedChild.parentTag) {
-                itemRefs.current?.set(nestedChild.parentTag, el)
+              if (el && parentGlobalIndex >= 0) {
+                itemRefs.current?.set(parentGlobalIndex, el)
               }
             }}
           >
@@ -606,7 +605,7 @@ const FolderContentsInner: React.FC<FolderContentsProps> = ({
  * Wrapper component that uses shared nested navigation state from context.
  * Handles registration of the base folder and navigation callbacks.
  */
-const FolderContents: React.FC<Omit<NestedTagRendererProps, never>> = (props) => {
+const FolderContents: React.FC<NestedTagRendererProps> = (props) => {
   const nestedNav = useNestedNavigation()
   const { currentFolder } = usePopoverContext()
 
@@ -639,7 +638,6 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
   nestedTag,
   group,
   flatTagList,
-  flatTagIndexMap,
   selectedIndex,
   setSelectedIndex,
   handleTagSelect,
@@ -655,7 +653,7 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
     const folderId = `${group.blockId}-${nestedTag.key}`
 
     const parentGlobalIndex = nestedTag.parentTag
-      ? (flatTagIndexMap.get(nestedTag.parentTag) ?? -1)
+      ? flatTagList.findIndex((item) => item.tag === nestedTag.parentTag)
       : -1
 
     return (
@@ -677,8 +675,8 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
           }
         }}
         ref={(el) => {
-          if (el && nestedTag.parentTag) {
-            itemRefs.current?.set(nestedTag.parentTag, el)
+          if (el && parentGlobalIndex >= 0) {
+            itemRefs.current?.set(parentGlobalIndex, el)
           }
         }}
       >
@@ -686,7 +684,6 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
           nestedTag={nestedTag}
           group={group}
           flatTagList={flatTagList}
-          flatTagIndexMap={flatTagIndexMap}
           selectedIndex={selectedIndex}
           setSelectedIndex={setSelectedIndex}
           handleTagSelect={handleTagSelect}
@@ -698,7 +695,10 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
     )
   }
 
-  const globalIndex = nestedTag.fullTag ? (flatTagIndexMap.get(nestedTag.fullTag) ?? -1) : -1
+  // Leaf tag - render as a simple PopoverItem
+  const globalIndex = nestedTag.fullTag
+    ? flatTagList.findIndex((item) => item.tag === nestedTag.fullTag)
+    : -1
 
   let tagDescription = ''
 
@@ -751,8 +751,8 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
         }
       }}
       ref={(el) => {
-        if (el && nestedTag.fullTag) {
-          itemRefs.current?.set(nestedTag.fullTag, el)
+        if (el && globalIndex >= 0) {
+          itemRefs.current?.set(globalIndex, el)
         }
       }}
     >
@@ -767,7 +767,7 @@ const NestedTagRenderer: React.FC<NestedTagRendererProps> = ({
 }
 
 /**
- * Hook to get mouse enter handler that respects keyboard navigation state.
+ * Hook to get mouse enter handler that respects keyboard navigation mode.
  * Returns a handler that only updates selection if not in keyboard mode.
  */
 const useKeyboardAwareMouseEnter = (
@@ -794,7 +794,7 @@ const VariableTagItem: React.FC<{
   selectedIndex: number
   setSelectedIndex: (index: number) => void
   handleTagSelect: (tag: string) => void
-  itemRefs: React.RefObject<Map<string, HTMLElement>>
+  itemRefs: React.RefObject<Map<number, HTMLElement>>
   variableInfo: { type: string; id: string } | null
 }> = ({
   tag,
@@ -819,8 +819,8 @@ const VariableTagItem: React.FC<{
         handleTagSelect(tag)
       }}
       ref={(el) => {
-        if (el) {
-          itemRefs.current?.set(tag, el)
+        if (el && globalIndex >= 0) {
+          itemRefs.current?.set(globalIndex, el)
         }
       }}
     >
@@ -845,7 +845,7 @@ const BlockRootTagItem: React.FC<{
   selectedIndex: number
   setSelectedIndex: (index: number) => void
   handleTagSelect: (tag: string, group?: BlockTagGroup) => void
-  itemRefs: React.RefObject<Map<string, HTMLElement>>
+  itemRefs: React.RefObject<Map<number, HTMLElement>>
   group: BlockTagGroup
   tagIcon: string | React.ComponentType<{ className?: string }>
   blockColor: string
@@ -875,8 +875,8 @@ const BlockRootTagItem: React.FC<{
         handleTagSelect(rootTag, group)
       }}
       ref={(el) => {
-        if (el) {
-          itemRefs.current?.set(rootTag, el)
+        if (el && rootTagGlobalIndex >= 0) {
+          itemRefs.current?.set(rootTagGlobalIndex, el)
         }
       }}
     >
@@ -916,12 +916,16 @@ const TagDropdownBackButton: React.FC = () => {
 
   const handleBackClick = (e: React.MouseEvent) => {
     e.stopPropagation()
+    // Try to navigate back in nested path first
     if (nestedNav?.navigateBack()) {
+      // Successfully navigated back one level
       return
     }
+    // At root folder level, close the folder
     closeFolder()
   }
 
+  // Just render the back button - the parent tag is rendered as the first item in FolderContentsInner
   return (
     <div
       className={cn(
@@ -982,7 +986,7 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
   inputRef,
 }) => {
   const [selectedIndex, setSelectedIndex] = useState(0)
-  const itemRefs = useRef<Map<string, HTMLElement>>(new Map())
+  const itemRefs = useRef<Map<number, HTMLElement>>(new Map())
 
   const [nestedPath, setNestedPath] = useState<NestedTag[]>([])
   const baseFolderRef = useRef<{
@@ -994,11 +998,6 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
   const handleTagSelectRef = useRef<((tag: string, group?: BlockTagGroup) => void) | null>(null)
   const scrollAreaRef = useRef<HTMLDivElement>(null)
 
-  const inputValueRef = useRef(inputValue)
-  const cursorPositionRef = useRef(cursorPosition)
-  inputValueRef.current = inputValue
-  cursorPositionRef.current = cursorPosition
-
   const { blocks, edges, loops, parallels } = useWorkflowStore(
     useShallow((state) => ({
       blocks: state.blocks,
@@ -1701,27 +1700,27 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
     return list
   }, [variableTags, nestedBlockTagGroups])
 
-  /**
-   * Map from tag string to its index in flatTagList for O(1) lookups.
-   * Replaces O(n) findIndex calls throughout the component.
-   */
-  const flatTagIndexMap = useMemo(() => {
-    const map = new Map<string, number>()
-    flatTagList.forEach((item, index) => {
-      map.set(item.tag, index)
-    })
-    return map
-  }, [flatTagList])
+  useEffect(() => {
+    if (!visible || selectedIndex < 0) return
+
+    const element = itemRefs.current.get(selectedIndex)
+    if (element) {
+      element.scrollIntoView({
+        behavior: 'auto',
+        block: 'nearest',
+      })
+    }
+  }, [selectedIndex, visible])
 
   const handleTagSelect = useCallback(
     (tag: string, blockGroup?: BlockTagGroup) => {
-      let liveCursor = cursorPositionRef.current
-      let liveValue = inputValueRef.current
+      let liveCursor = cursorPosition
+      let liveValue = inputValue
 
       if (typeof window !== 'undefined' && document?.activeElement) {
         const activeEl = document.activeElement as HTMLInputElement | HTMLTextAreaElement | null
         if (activeEl && typeof activeEl.selectionStart === 'number') {
-          liveCursor = activeEl.selectionStart ?? cursorPositionRef.current
+          liveCursor = activeEl.selectionStart ?? cursorPosition
           if ('value' in activeEl && typeof activeEl.value === 'string') {
             liveValue = activeEl.value
           }
@@ -1806,7 +1805,7 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
       onSelect(newValue)
       onClose?.()
     },
-    [workflowVariables, onSelect, onClose, getMergedSubBlocks]
+    [inputValue, cursorPosition, workflowVariables, onSelect, onClose, getMergedSubBlocks]
   )
 
   handleTagSelectRef.current = handleTagSelect
@@ -1878,6 +1877,9 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
       },
       registerFolder: (folderId, folderTitle, baseTag, group) => {
         baseFolderRef.current = { id: folderId, title: folderTitle, baseTag, group }
+        if (scrollAreaRef.current) {
+          scrollAreaRef.current.scrollTop = 0
+        }
       },
     }),
     [nestedPath]
@@ -1890,9 +1892,13 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
     }
   }, [visible])
 
+  useEffect(() => setSelectedIndex(0), [searchTerm])
+
   useEffect(() => {
-    setSelectedIndex(0)
-  }, [flatTagList.length])
+    if (selectedIndex >= flatTagList.length) {
+      setSelectedIndex(Math.max(0, flatTagList.length - 1))
+    }
+  }, [flatTagList.length, selectedIndex])
 
   useEffect(() => {
     if (visible) {
@@ -1911,28 +1917,20 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
     }
   }, [visible, onClose])
 
-  /**
-   * Memoized caret position and side calculation.
-   * getCaretViewportPosition does DOM manipulation, so we avoid calling it on every render.
-   */
-  const { caretViewport, side } = useMemo(() => {
-    const inputElement = inputRef?.current
-    if (!inputElement) {
-      return { caretViewport: { left: 0, top: 0 }, side: 'bottom' as const }
-    }
-
-    const viewport = getCaretViewportPosition(inputElement, cursorPosition, inputValue)
-    const margin = 8
-    const spaceAbove = viewport.top - margin
-    const spaceBelow = window.innerHeight - viewport.top - margin
-    const computedSide: 'top' | 'bottom' = spaceBelow >= spaceAbove ? 'bottom' : 'top'
-
-    return { caretViewport: viewport, side: computedSide }
-  }, [cursorPosition, inputValue, inputRef])
-
   if (!visible || tags.length === 0 || flatTagList.length === 0) return null
 
   const inputElement = inputRef?.current
+  let caretViewport = { left: 0, top: 0 }
+  let side: 'top' | 'bottom' = 'bottom'
+
+  if (inputElement) {
+    caretViewport = getCaretViewportPosition(inputElement, cursorPosition, inputValue)
+
+    const margin = 8
+    const spaceAbove = caretViewport.top - margin
+    const spaceBelow = window.innerHeight - caretViewport.top - margin
+    side = spaceBelow >= spaceAbove ? 'bottom' : 'top'
+  }
 
   return (
     <NestedNavigationContext.Provider value={nestedNavigationValue}>
@@ -1958,11 +1956,6 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
           flatTagList={flatTagList}
           nestedBlockTagGroups={nestedBlockTagGroups}
           handleTagSelect={handleTagSelect}
-          onFolderEnter={() => {
-            if (scrollAreaRef.current) {
-              scrollAreaRef.current.scrollTop = 0
-            }
-          }}
         />
         <PopoverContent
           maxHeight={240}
@@ -1991,7 +1984,7 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
                     </PopoverSection>
                     {variableTags.map((tag: string) => {
                       const variableInfo = variableInfoMap?.[tag] || null
-                      const globalIndex = flatTagIndexMap.get(tag) ?? -1
+                      const globalIndex = flatTagList.findIndex((item) => item.tag === tag)
 
                       return (
                         <VariableTagItem
@@ -2034,7 +2027,7 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
                   const rootTagFromTags = group.tags.find((tag) => tag === normalizedBlockName)
                   const rootTag = rootTagFromTags || normalizedBlockName
 
-                  const rootTagGlobalIndex = flatTagIndexMap.get(rootTag) ?? -1
+                  const rootTagGlobalIndex = flatTagList.findIndex((item) => item.tag === rootTag)
 
                   return (
                     <div key={group.blockId}>
@@ -2061,7 +2054,6 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
                             nestedTag={nestedTag}
                             group={group}
                             flatTagList={flatTagList}
-                            flatTagIndexMap={flatTagIndexMap}
                             selectedIndex={selectedIndex}
                             setSelectedIndex={setSelectedIndex}
                             handleTagSelect={handleTagSelect}

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

@@ -180,6 +180,20 @@ function resolveCustomToolFromReference(
   return null
 }
 
+/**
+ * Checks if a stored custom tool uses the reference-only format.
+ *
+ * @remarks
+ * Reference-only format means the tool has a customToolId but no inline code/schema,
+ * requiring resolution from the database at runtime.
+ *
+ * @param storedTool - The stored tool to check
+ * @returns `true` if the tool is a reference-only custom tool, `false` otherwise
+ */
+function isCustomToolReference(storedTool: StoredTool): boolean {
+  return storedTool.type === 'custom-tool' && !!storedTool.customToolId && !storedTool.code
+}
+
 /**
  * Generic sync wrapper that synchronizes store values with local component state.
  *
@@ -1141,6 +1155,21 @@ export const ToolInput = memo(function ToolInput({
     return filterBlocks(allToolBlocks)
   }, [filterBlocks])
 
+  const customFilter = useCallback((value: string, search: string) => {
+    if (!search.trim()) return 1
+
+    const normalizedValue = value.toLowerCase()
+    const normalizedSearch = search.toLowerCase()
+
+    if (normalizedValue === normalizedSearch) return 1
+
+    if (normalizedValue.startsWith(normalizedSearch)) return 0.8
+
+    if (normalizedValue.includes(normalizedSearch)) return 0.6
+
+    return 0
+  }, [])
+
   const hasBackfilledRef = useRef(false)
   useEffect(() => {
     if (

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

@@ -1,261 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { describe, expect, it } from 'vitest'
-import type { SubBlockConfig } from '@/blocks/types'
-
-const isFieldRequired = (config: SubBlockConfig, subBlockValues?: Record<string, any>): boolean => {
-  if (!config.required) return false
-  if (typeof config.required === 'boolean') return config.required
-
-  const evalCond = (
-    cond: {
-      field: string
-      value: string | number | boolean | Array<string | number | boolean>
-      not?: boolean
-      and?: {
-        field: string
-        value: string | number | boolean | Array<string | number | boolean> | undefined
-        not?: boolean
-      }
-    },
-    values: Record<string, any>
-  ): boolean => {
-    const fieldValue = values[cond.field]?.value
-    const condValue = cond.value
-
-    let match: boolean
-    if (Array.isArray(condValue)) {
-      match = condValue.includes(fieldValue)
-    } else {
-      match = fieldValue === condValue
-    }
-
-    if (cond.not) match = !match
-
-    if (cond.and) {
-      const andFieldValue = values[cond.and.field]?.value
-      const andCondValue = cond.and.value
-      let andMatch: boolean
-      if (Array.isArray(andCondValue)) {
-        andMatch = andCondValue.includes(andFieldValue)
-      } else {
-        andMatch = andFieldValue === andCondValue
-      }
-      if (cond.and.not) andMatch = !andMatch
-      match = match && andMatch
-    }
-
-    return match
-  }
-
-  const condition = typeof config.required === 'function' ? config.required() : config.required
-  return evalCond(condition, subBlockValues || {})
-}
-
-describe('isFieldRequired', () => {
-  describe('boolean required', () => {
-    it.concurrent('returns false when required is not set', () => {
-      const config = { id: 'test', type: 'short-input' } as SubBlockConfig
-      expect(isFieldRequired(config, {})).toBe(false)
-    })
-
-    it.concurrent('returns false when required is false', () => {
-      const config = { id: 'test', type: 'short-input', required: false } as SubBlockConfig
-      expect(isFieldRequired(config, {})).toBe(false)
-    })
-
-    it.concurrent('returns true when required is true', () => {
-      const config = { id: 'test', type: 'short-input', required: true } as SubBlockConfig
-      expect(isFieldRequired(config, {})).toBe(true)
-    })
-  })
-
-  describe('conditional required - simple value matching', () => {
-    it.concurrent('returns true when field value matches condition value', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: 'create_booking' },
-      } as SubBlockConfig
-      const values = { operation: { value: 'create_booking' } }
-      expect(isFieldRequired(config, values)).toBe(true)
-    })
-
-    it.concurrent('returns false when field value does not match condition value', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: 'create_booking' },
-      } as SubBlockConfig
-      const values = { operation: { value: 'cancel_booking' } }
-      expect(isFieldRequired(config, values)).toBe(false)
-    })
-
-    it.concurrent('returns false when field is missing', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: 'create_booking' },
-      } as SubBlockConfig
-      expect(isFieldRequired(config, {})).toBe(false)
-    })
-
-    it.concurrent('returns false when field value is undefined', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: 'create_booking' },
-      } as SubBlockConfig
-      const values = { operation: { value: undefined } }
-      expect(isFieldRequired(config, values)).toBe(false)
-    })
-  })
-
-  describe('conditional required - array value matching', () => {
-    it.concurrent('returns true when field value is in condition array', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: ['create_booking', 'update_booking'] },
-      } as SubBlockConfig
-      const values = { operation: { value: 'create_booking' } }
-      expect(isFieldRequired(config, values)).toBe(true)
-    })
-
-    it.concurrent('returns false when field value is not in condition array', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: ['create_booking', 'update_booking'] },
-      } as SubBlockConfig
-      const values = { operation: { value: 'cancel_booking' } }
-      expect(isFieldRequired(config, values)).toBe(false)
-    })
-  })
-
-  describe('conditional required - negation', () => {
-    it.concurrent('returns false when field matches but not is true', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: 'create_booking', not: true },
-      } as SubBlockConfig
-      const values = { operation: { value: 'create_booking' } }
-      expect(isFieldRequired(config, values)).toBe(false)
-    })
-
-    it.concurrent('returns true when field does not match and not is true', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: { field: 'operation', value: 'create_booking', not: true },
-      } as SubBlockConfig
-      const values = { operation: { value: 'cancel_booking' } }
-      expect(isFieldRequired(config, values)).toBe(true)
-    })
-  })
-
-  describe('conditional required - compound conditions', () => {
-    it.concurrent('returns true when both conditions match', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: {
-          field: 'operation',
-          value: 'create_booking',
-          and: { field: 'hasEmail', value: true },
-        },
-      } as SubBlockConfig
-      const values = {
-        operation: { value: 'create_booking' },
-        hasEmail: { value: true },
-      }
-      expect(isFieldRequired(config, values)).toBe(true)
-    })
-
-    it.concurrent('returns false when first matches but and fails', () => {
-      const config = {
-        id: 'test',
-        type: 'short-input',
-        required: {
-          field: 'operation',
-          value: 'create_booking',
-          and: { field: 'hasEmail', value: true },
-        },
-      } as SubBlockConfig
-      const values = {
-        operation: { value: 'create_booking' },
-        hasEmail: { value: false },
-      }
-      expect(isFieldRequired(config, values)).toBe(false)
-    })
-  })
-})
-
-describe('condition + required equivalence', () => {
-  const conditionValue = { field: 'operation', value: 'calcom_create_booking' }
-
-  const configWithConditionalRequired = {
-    id: 'attendeeName',
-    type: 'short-input',
-    condition: conditionValue,
-    required: conditionValue,
-  } as SubBlockConfig
-
-  const configWithSimpleRequired = {
-    id: 'attendeeName',
-    type: 'short-input',
-    condition: conditionValue,
-    required: true,
-  } as SubBlockConfig
-
-  describe('when condition IS met (field is visible)', () => {
-    const valuesWhenVisible = { operation: { value: 'calcom_create_booking' } }
-
-    it.concurrent('conditional required returns true', () => {
-      expect(isFieldRequired(configWithConditionalRequired, valuesWhenVisible)).toBe(true)
-    })
-
-    it.concurrent('simple required returns true', () => {
-      expect(isFieldRequired(configWithSimpleRequired, valuesWhenVisible)).toBe(true)
-    })
-
-    it.concurrent('both configs produce the same result', () => {
-      const conditionalResult = isFieldRequired(configWithConditionalRequired, valuesWhenVisible)
-      const simpleResult = isFieldRequired(configWithSimpleRequired, valuesWhenVisible)
-      expect(conditionalResult).toBe(simpleResult)
-    })
-  })
-
-  describe('when condition is NOT met (field is hidden)', () => {
-    const valuesWhenHidden = { operation: { value: 'calcom_cancel_booking' } }
-
-    it.concurrent('conditional required returns false', () => {
-      expect(isFieldRequired(configWithConditionalRequired, valuesWhenHidden)).toBe(false)
-    })
-
-    it.concurrent('simple required returns true but field is hidden', () => {
-      expect(isFieldRequired(configWithSimpleRequired, valuesWhenHidden)).toBe(true)
-    })
-
-    it.concurrent('results differ but field is hidden when condition fails', () => {
-      const conditionalResult = isFieldRequired(configWithConditionalRequired, valuesWhenHidden)
-      const simpleResult = isFieldRequired(configWithSimpleRequired, valuesWhenHidden)
-      expect(conditionalResult).not.toBe(simpleResult)
-    })
-  })
-
-  describe('practical equivalence for user-facing behavior', () => {
-    it.concurrent('when field is visible both show required indicator', () => {
-      const valuesWhenVisible = { operation: { value: 'calcom_create_booking' } }
-      const showsRequiredIndicatorA = isFieldRequired(
-        configWithConditionalRequired,
-        valuesWhenVisible
-      )
-      const showsRequiredIndicatorB = isFieldRequired(configWithSimpleRequired, valuesWhenVisible)
-      expect(showsRequiredIndicatorA).toBe(true)
-      expect(showsRequiredIndicatorB).toBe(true)
-    })
-  })
-})

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

@@ -1,6 +1,6 @@
-import { type JSX, type MouseEvent, memo, useCallback, useRef, useState } from 'react'
+import { type JSX, type MouseEvent, memo, useRef, useState } from 'react'
 import { isEqual } from 'lodash'
-import { AlertTriangle, ArrowLeftRight, ArrowUp, Check, Clipboard } from 'lucide-react'
+import { AlertTriangle, ArrowLeftRight, ArrowUp } 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'
@@ -44,7 +44,6 @@ import {
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components'
 import { useDependsOnGate } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-depends-on-gate'
 import type { SubBlockConfig } from '@/blocks/types'
-import { useWebhookManagement } from '@/hooks/use-webhook-management'
 
 /**
  * Interface for wand control handlers exposed by sub-block inputs
@@ -196,12 +195,7 @@ const renderLabel = (
     disabled?: boolean
     onToggle?: () => void
   },
-  canonicalToggleIsDisabled?: boolean,
-  copyState?: {
-    showCopyButton: boolean
-    copied: boolean
-    onCopy: () => void
-  }
+  canonicalToggleIsDisabled?: boolean
 ): JSX.Element | null => {
   if (config.type === 'switch') return null
   if (!config.title) return null
@@ -209,7 +203,6 @@ const renderLabel = (
   const required = isFieldRequired(config, subBlockValues)
   const showWand = wandState?.isWandEnabled && !wandState.isPreview && !wandState.disabled
   const showCanonicalToggle = !!canonicalToggle && !wandState?.isPreview
-  const showCopy = copyState?.showCopyButton && !wandState?.isPreview
   const canonicalToggleDisabledResolved = canonicalToggleIsDisabled ?? canonicalToggle?.disabled
 
   return (
@@ -234,27 +227,6 @@ const renderLabel = (
           )}
       </Label>
       <div className='flex items-center gap-[6px]'>
-        {showCopy && (
-          <Tooltip.Root>
-            <Tooltip.Trigger asChild>
-              <button
-                type='button'
-                onClick={copyState.onCopy}
-                className='-my-1 flex h-5 w-5 items-center justify-center'
-                aria-label='Copy value'
-              >
-                {copyState.copied ? (
-                  <Check className='h-3 w-3 text-green-500' />
-                ) : (
-                  <Clipboard className='h-3 w-3 text-muted-foreground' />
-                )}
-              </button>
-            </Tooltip.Trigger>
-            <Tooltip.Content side='top'>
-              <p>{copyState.copied ? 'Copied!' : 'Copy'}</p>
-            </Tooltip.Content>
-          </Tooltip.Root>
-        )}
         {showWand && (
           <>
             {!wandState.isSearchActive ? (
@@ -413,18 +385,9 @@ function SubBlockComponent({
   const [isValidJson, setIsValidJson] = useState(true)
   const [isSearchActive, setIsSearchActive] = useState(false)
   const [searchQuery, setSearchQuery] = useState('')
-  const [copied, setCopied] = useState(false)
   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,
-    isPreview,
-    useWebhookUrl: config.useWebhookUrl,
-  })
-
   const handleMouseDown = (e: MouseEvent<HTMLDivElement>): void => {
     e.stopPropagation()
   }
@@ -435,18 +398,6 @@ function SubBlockComponent({
 
   const isWandEnabled = config.wandConfig?.enabled ?? false
 
-  /**
-   * Handles copying the webhook URL to clipboard.
-   */
-  const handleCopy = useCallback(() => {
-    const textToCopy = webhookManagement?.webhookUrl
-    if (textToCopy) {
-      navigator.clipboard.writeText(textToCopy)
-      setCopied(true)
-      setTimeout(() => setCopied(false), 2000)
-    }
-  }, [webhookManagement?.webhookUrl])
-
   /**
    * Handles wand icon click to activate inline prompt mode.
    * Focuses the input after a brief delay to ensure DOM is ready.
@@ -531,6 +482,7 @@ function SubBlockComponent({
             placeholder={config.placeholder}
             password={config.password}
             readOnly={config.readOnly}
+            showCopyButton={config.showCopyButton}
             useWebhookUrl={config.useWebhookUrl}
             config={config}
             isPreview={isPreview}
@@ -1027,12 +979,7 @@ function SubBlockComponent({
           searchInputRef,
         },
         canonicalToggle,
-        Boolean(canonicalToggle?.disabled || disabled || isPreview),
-        {
-          showCopyButton: Boolean(config.showCopyButton && config.useWebhookUrl),
-          copied,
-          onCopy: handleCopy,
-        }
+        Boolean(canonicalToggle?.disabled || disabled || isPreview)
       )}
       {renderInput()}
     </div>

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/filter-popover/filter-popover.tsx

@@ -1,121 +0,0 @@
-'use client'
-
-import { memo } from 'react'
-import clsx from 'clsx'
-import { Filter } from 'lucide-react'
-import {
-  Button,
-  Popover,
-  PopoverContent,
-  PopoverDivider,
-  PopoverItem,
-  PopoverScrollArea,
-  PopoverSection,
-  PopoverTrigger,
-} from '@/components/emcn'
-import type {
-  BlockInfo,
-  TerminalFilters,
-} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types'
-import { getBlockIcon } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/utils'
-
-/**
- * Props for the FilterPopover component
- */
-export interface FilterPopoverProps {
-  open: boolean
-  onOpenChange: (open: boolean) => void
-  filters: TerminalFilters
-  toggleStatus: (status: 'error' | 'info') => void
-  toggleBlock: (blockId: string) => void
-  uniqueBlocks: BlockInfo[]
-  hasActiveFilters: boolean
-}
-
-/**
- * Filter popover component used in terminal header and output panel
- */
-export const FilterPopover = memo(function FilterPopover({
-  open,
-  onOpenChange,
-  filters,
-  toggleStatus,
-  toggleBlock,
-  uniqueBlocks,
-  hasActiveFilters,
-}: FilterPopoverProps) {
-  return (
-    <Popover open={open} onOpenChange={onOpenChange} size='sm'>
-      <PopoverTrigger asChild>
-        <Button
-          variant='ghost'
-          className='!p-1.5 -m-1.5'
-          onClick={(e) => e.stopPropagation()}
-          aria-label='Filters'
-        >
-          <Filter
-            className={clsx('h-3 w-3', hasActiveFilters && 'text-[var(--brand-secondary)]')}
-          />
-        </Button>
-      </PopoverTrigger>
-      <PopoverContent
-        side='top'
-        align='end'
-        sideOffset={4}
-        onClick={(e) => e.stopPropagation()}
-        minWidth={160}
-        maxWidth={220}
-        maxHeight={300}
-      >
-        <PopoverSection>Status</PopoverSection>
-        <PopoverItem
-          active={filters.statuses.has('error')}
-          showCheck={filters.statuses.has('error')}
-          onClick={() => toggleStatus('error')}
-        >
-          <div
-            className='h-[6px] w-[6px] rounded-[2px]'
-            style={{ backgroundColor: 'var(--text-error)' }}
-          />
-          <span className='flex-1'>Error</span>
-        </PopoverItem>
-        <PopoverItem
-          active={filters.statuses.has('info')}
-          showCheck={filters.statuses.has('info')}
-          onClick={() => toggleStatus('info')}
-        >
-          <div
-            className='h-[6px] w-[6px] rounded-[2px]'
-            style={{ backgroundColor: 'var(--terminal-status-info-color)' }}
-          />
-          <span className='flex-1'>Info</span>
-        </PopoverItem>
-
-        {uniqueBlocks.length > 0 && (
-          <>
-            <PopoverDivider className='my-[4px]' />
-            <PopoverSection className='!mt-0'>Blocks</PopoverSection>
-            <PopoverScrollArea className='max-h-[100px]'>
-              {uniqueBlocks.map((block) => {
-                const BlockIcon = getBlockIcon(block.blockType)
-                const isSelected = filters.blockIds.has(block.blockId)
-
-                return (
-                  <PopoverItem
-                    key={block.blockId}
-                    active={isSelected}
-                    showCheck={isSelected}
-                    onClick={() => toggleBlock(block.blockId)}
-                  >
-                    {BlockIcon && <BlockIcon className='h-3 w-3' />}
-                    <span className='flex-1'>{block.blockName}</span>
-                  </PopoverItem>
-                )
-              })}
-            </PopoverScrollArea>
-          </>
-        )}
-      </PopoverContent>
-    </Popover>
-  )
-})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/filter-popover/index.ts

@@ -1 +0,0 @@
-export { FilterPopover, type FilterPopoverProps } from './filter-popover'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/index.ts

@@ -1,5 +1,2 @@
-export { FilterPopover, type FilterPopoverProps } from './filter-popover'
-export { LogRowContextMenu, type LogRowContextMenuProps } from './log-row-context-menu'
-export { OutputPanel, type OutputPanelProps } from './output-panel'
-export { RunningBadge, StatusDisplay, type StatusDisplayProps } from './status-display'
-export { ToggleButton, type ToggleButtonProps } from './toggle-button'
+export { LogRowContextMenu } from './log-row-context-menu'
+export { OutputContextMenu } from './output-context-menu'

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

@@ -1,6 +1,6 @@
 'use client'
 
-import { memo, type RefObject } from 'react'
+import type { RefObject } from 'react'
 import {
   Popover,
   PopoverAnchor,
@@ -8,13 +8,20 @@ import {
   PopoverDivider,
   PopoverItem,
 } from '@/components/emcn'
-import type {
-  ContextMenuPosition,
-  TerminalFilters,
-} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types'
 import type { ConsoleEntry } from '@/stores/terminal'
 
-export interface LogRowContextMenuProps {
+interface ContextMenuPosition {
+  x: number
+  y: number
+}
+
+interface TerminalFilters {
+  blockIds: Set<string>
+  statuses: Set<'error' | 'info'>
+  runIds: Set<string>
+}
+
+interface LogRowContextMenuProps {
   isOpen: boolean
   position: ContextMenuPosition
   menuRef: RefObject<HTMLDivElement | null>
@@ -23,16 +30,19 @@ export interface LogRowContextMenuProps {
   filters: TerminalFilters
   onFilterByBlock: (blockId: string) => void
   onFilterByStatus: (status: 'error' | 'info') => void
+  onFilterByRunId: (runId: string) => void
   onCopyRunId: (runId: string) => void
+  onClearFilters: () => void
   onClearConsole: () => void
   onFixInCopilot: (entry: ConsoleEntry) => void
+  hasActiveFilters: boolean
 }
 
 /**
  * Context menu for terminal log rows (left side).
  * Displays filtering options based on the selected row's properties.
  */
-export const LogRowContextMenu = memo(function LogRowContextMenu({
+export function LogRowContextMenu({
   isOpen,
   position,
   menuRef,
@@ -41,15 +51,19 @@ export const LogRowContextMenu = memo(function LogRowContextMenu({
   filters,
   onFilterByBlock,
   onFilterByStatus,
+  onFilterByRunId,
   onCopyRunId,
+  onClearFilters,
   onClearConsole,
   onFixInCopilot,
+  hasActiveFilters,
 }: LogRowContextMenuProps) {
   const hasRunId = entry?.executionId != null
 
   const isBlockFiltered = entry ? filters.blockIds.has(entry.blockId) : false
   const entryStatus = entry?.success ? 'info' : 'error'
   const isStatusFiltered = entry ? filters.statuses.has(entryStatus) : false
+  const isRunIdFiltered = entry?.executionId ? filters.runIds.has(entry.executionId) : false
 
   return (
     <Popover
@@ -120,11 +134,34 @@ export const LogRowContextMenu = memo(function LogRowContextMenu({
             >
               Filter by Status
             </PopoverItem>
+            {hasRunId && (
+              <PopoverItem
+                showCheck={isRunIdFiltered}
+                onClick={() => {
+                  onFilterByRunId(entry.executionId!)
+                  onClose()
+                }}
+              >
+                Filter by Run ID
+              </PopoverItem>
+            )}
           </>
         )}
 
+        {/* Clear filters */}
+        {hasActiveFilters && (
+          <PopoverItem
+            onClick={() => {
+              onClearFilters()
+              onClose()
+            }}
+          >
+            Clear All Filters
+          </PopoverItem>
+        )}
+
         {/* Destructive action */}
-        {entry && <PopoverDivider />}
+        {(entry || hasActiveFilters) && <PopoverDivider />}
         <PopoverItem
           onClick={() => {
             onClearConsole()
@@ -136,4 +173,4 @@ export const LogRowContextMenu = memo(function LogRowContextMenu({
       </PopoverContent>
     </Popover>
   )
-})
+}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/log-row-context-menu/index.ts

@@ -1 +0,0 @@
-export { LogRowContextMenu, type LogRowContextMenuProps } from './log-row-context-menu'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/output-context-menu.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { memo, type RefObject } from 'react'
+import type { RefObject } from 'react'
 import {
   Popover,
   PopoverAnchor,
@@ -8,9 +8,13 @@ import {
   PopoverDivider,
   PopoverItem,
 } from '@/components/emcn'
-import type { ContextMenuPosition } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types'
 
-export interface OutputContextMenuProps {
+interface ContextMenuPosition {
+  x: number
+  y: number
+}
+
+interface OutputContextMenuProps {
   isOpen: boolean
   position: ContextMenuPosition
   menuRef: RefObject<HTMLDivElement | null>
@@ -18,8 +22,6 @@ export interface OutputContextMenuProps {
   onCopySelection: () => void
   onCopyAll: () => void
   onSearch: () => void
-  structuredView: boolean
-  onToggleStructuredView: () => void
   wrapText: boolean
   onToggleWrap: () => void
   openOnRun: boolean
@@ -32,7 +34,7 @@ export interface OutputContextMenuProps {
  * Context menu for terminal output panel (right side).
  * Displays copy, search, and display options for the code viewer.
  */
-export const OutputContextMenu = memo(function OutputContextMenu({
+export function OutputContextMenu({
   isOpen,
   position,
   menuRef,
@@ -40,8 +42,6 @@ export const OutputContextMenu = memo(function OutputContextMenu({
   onCopySelection,
   onCopyAll,
   onSearch,
-  structuredView,
-  onToggleStructuredView,
   wrapText,
   onToggleWrap,
   openOnRun,
@@ -96,9 +96,6 @@ export const OutputContextMenu = memo(function OutputContextMenu({
 
         {/* Display settings - toggles don't close menu */}
         <PopoverDivider />
-        <PopoverItem showCheck={structuredView} onClick={onToggleStructuredView}>
-          Structured View
-        </PopoverItem>
         <PopoverItem showCheck={wrapText} onClick={onToggleWrap}>
           Wrap Text
         </PopoverItem>
@@ -119,4 +116,4 @@ export const OutputContextMenu = memo(function OutputContextMenu({
       </PopoverContent>
     </Popover>
   )
-})
+}

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/output-panel/components/structured-output.tsx

@@ -1,913 +0,0 @@
-'use client'
-
-import type React from 'react'
-import {
-  createContext,
-  memo,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react'
-import { List, type RowComponentProps, useListRef } from 'react-window'
-import { Badge, ChevronDown } from '@/components/emcn'
-import { cn } from '@/lib/core/utils/cn'
-
-type ValueType = 'null' | 'undefined' | 'array' | 'string' | 'number' | 'boolean' | 'object'
-type BadgeVariant = 'green' | 'blue' | 'orange' | 'purple' | 'gray' | 'red'
-
-interface NodeEntry {
-  key: string
-  value: unknown
-  path: string
-}
-
-/**
- * Search context for structured output tree.
- */
-interface SearchContextValue {
-  query: string
-  pathToMatchIndices: Map<string, number[]>
-}
-
-const SearchContext = createContext<SearchContextValue | null>(null)
-
-/**
- * Configuration for virtualized rendering.
- */
-const CONFIG = {
-  ROW_HEIGHT: 22,
-  INDENT_PER_LEVEL: 12,
-  BASE_PADDING: 20,
-  MAX_SEARCH_DEPTH: 100,
-  OVERSCAN_COUNT: 10,
-  VIRTUALIZATION_THRESHOLD: 200,
-} as const
-
-const BADGE_VARIANTS: Record<ValueType, BadgeVariant> = {
-  string: 'green',
-  number: 'blue',
-  boolean: 'orange',
-  array: 'purple',
-  null: 'gray',
-  undefined: 'gray',
-  object: 'gray',
-} as const
-
-/**
- * Styling constants matching the original non-virtualized implementation.
- */
-const STYLES = {
-  row: 'group flex min-h-[22px] cursor-pointer items-center gap-[6px] rounded-[8px] px-[6px] -mx-[6px] hover:bg-[var(--surface-6)] dark:hover:bg-[var(--surface-5)]',
-  chevron:
-    'h-[8px] w-[8px] flex-shrink-0 text-[var(--text-tertiary)] transition-transform duration-100 group-hover:text-[var(--text-primary)]',
-  keyName:
-    'font-medium text-[13px] text-[var(--text-primary)] group-hover:text-[var(--text-primary)]',
-  badge: 'rounded-[4px] px-[4px] py-[0px] text-[11px]',
-  summary: 'text-[12px] text-[var(--text-tertiary)]',
-  indent:
-    'mt-[2px] ml-[3px] flex min-w-0 flex-col gap-[2px] border-[var(--border)] border-l pl-[9px]',
-  value: 'min-w-0 py-[2px] text-[13px] text-[var(--text-primary)]',
-  emptyValue: 'py-[2px] text-[13px] text-[var(--text-tertiary)]',
-  matchHighlight: 'bg-yellow-200/60 dark:bg-yellow-500/40',
-  currentMatchHighlight: 'bg-orange-400',
-} as const
-
-const EMPTY_MATCH_INDICES: number[] = []
-
-function getTypeLabel(value: unknown): ValueType {
-  if (value === null) return 'null'
-  if (value === undefined) return 'undefined'
-  if (Array.isArray(value)) return 'array'
-  return typeof value as ValueType
-}
-
-function formatPrimitive(value: unknown): string {
-  if (value === null) return 'null'
-  if (value === undefined) return 'undefined'
-  return String(value)
-}
-
-function isPrimitive(value: unknown): value is null | undefined | string | number | boolean {
-  return value === null || value === undefined || typeof value !== 'object'
-}
-
-function isEmpty(value: unknown): boolean {
-  if (Array.isArray(value)) return value.length === 0
-  if (typeof value === 'object' && value !== null) return Object.keys(value).length === 0
-  return false
-}
-
-function extractErrorMessage(data: unknown): string {
-  if (typeof data === 'string') return data
-  if (data instanceof Error) return data.message
-  if (typeof data === 'object' && data !== null && 'message' in data) {
-    return String((data as { message: unknown }).message)
-  }
-  return JSON.stringify(data, null, 2)
-}
-
-function buildEntries(value: unknown, basePath: string): NodeEntry[] {
-  if (Array.isArray(value)) {
-    return value.map((item, i) => ({ key: String(i), value: item, path: `${basePath}[${i}]` }))
-  }
-  return Object.entries(value as Record<string, unknown>).map(([k, v]) => ({
-    key: k,
-    value: v,
-    path: `${basePath}.${k}`,
-  }))
-}
-
-function getCollapsedSummary(value: unknown): string | null {
-  if (Array.isArray(value)) {
-    const len = value.length
-    return `${len} item${len !== 1 ? 's' : ''}`
-  }
-  if (typeof value === 'object' && value !== null) {
-    const count = Object.keys(value).length
-    return `${count} key${count !== 1 ? 's' : ''}`
-  }
-  return null
-}
-
-function computeInitialPaths(data: unknown, isError: boolean): Set<string> {
-  if (isError) return new Set(['root.error'])
-  if (!data || typeof data !== 'object') return new Set()
-  const entries = Array.isArray(data)
-    ? data.map((_, i) => `root[${i}]`)
-    : Object.keys(data).map((k) => `root.${k}`)
-  return new Set(entries)
-}
-
-function getAncestorPaths(path: string): string[] {
-  const ancestors: string[] = []
-  let current = path
-
-  while (current.includes('.') || current.includes('[')) {
-    const splitPoint = Math.max(current.lastIndexOf('.'), current.lastIndexOf('['))
-    if (splitPoint <= 0) break
-    current = current.slice(0, splitPoint)
-    if (current !== 'root') ancestors.push(current)
-  }
-
-  return ancestors
-}
-
-function findTextMatches(text: string, query: string): Array<[number, number]> {
-  if (!query) return []
-
-  const matches: Array<[number, number]> = []
-  const lowerText = text.toLowerCase()
-  const lowerQuery = query.toLowerCase()
-  let pos = 0
-
-  while (pos < lowerText.length) {
-    const idx = lowerText.indexOf(lowerQuery, pos)
-    if (idx === -1) break
-    matches.push([idx, idx + query.length])
-    pos = idx + 1
-  }
-
-  return matches
-}
-
-function addPrimitiveMatches(value: unknown, path: string, query: string, matches: string[]): void {
-  const text = formatPrimitive(value)
-  const count = findTextMatches(text, query).length
-  for (let i = 0; i < count; i++) {
-    matches.push(path)
-  }
-}
-
-function collectAllMatchPaths(data: unknown, query: string, basePath: string, depth = 0): string[] {
-  if (!query || depth > CONFIG.MAX_SEARCH_DEPTH) return []
-
-  const matches: string[] = []
-
-  if (isPrimitive(data)) {
-    addPrimitiveMatches(data, `${basePath}.value`, query, matches)
-    return matches
-  }
-
-  for (const entry of buildEntries(data, basePath)) {
-    if (isPrimitive(entry.value)) {
-      addPrimitiveMatches(entry.value, entry.path, query, matches)
-    } else {
-      matches.push(...collectAllMatchPaths(entry.value, query, entry.path, depth + 1))
-    }
-  }
-
-  return matches
-}
-
-function buildPathToIndicesMap(matchPaths: string[]): Map<string, number[]> {
-  const map = new Map<string, number[]>()
-  matchPaths.forEach((path, globalIndex) => {
-    const existing = map.get(path)
-    if (existing) {
-      existing.push(globalIndex)
-    } else {
-      map.set(path, [globalIndex])
-    }
-  })
-  return map
-}
-
-/**
- * Renders text with search highlights using segments.
- */
-function renderHighlightedSegments(
-  text: string,
-  query: string,
-  matchIndices: number[],
-  currentMatchIndex: number,
-  path: string
-): React.ReactNode {
-  if (!query || matchIndices.length === 0) return text
-
-  const textMatches = findTextMatches(text, query)
-  if (textMatches.length === 0) return text
-
-  const segments: React.ReactNode[] = []
-  let lastEnd = 0
-
-  textMatches.forEach(([start, end], i) => {
-    const globalIndex = matchIndices[i]
-    const isCurrent = globalIndex === currentMatchIndex
-
-    if (start > lastEnd) {
-      segments.push(<span key={`t-${path}-${start}`}>{text.slice(lastEnd, start)}</span>)
-    }
-
-    segments.push(
-      <mark
-        key={`m-${path}-${start}`}
-        data-search-match
-        data-match-index={globalIndex}
-        className={cn(
-          'rounded-sm',
-          isCurrent ? STYLES.currentMatchHighlight : STYLES.matchHighlight
-        )}
-      >
-        {text.slice(start, end)}
-      </mark>
-    )
-    lastEnd = end
-  })
-
-  if (lastEnd < text.length) {
-    segments.push(<span key={`t-${path}-${lastEnd}`}>{text.slice(lastEnd)}</span>)
-  }
-
-  return <>{segments}</>
-}
-
-interface HighlightedTextProps {
-  text: string
-  matchIndices: number[]
-  path: string
-  currentMatchIndex: number
-}
-
-/**
- * Renders text with search highlights for non-virtualized mode.
- * Accepts currentMatchIndex as prop to ensure re-render when it changes.
- */
-const HighlightedText = memo(function HighlightedText({
-  text,
-  matchIndices,
-  path,
-  currentMatchIndex,
-}: HighlightedTextProps) {
-  const searchContext = useContext(SearchContext)
-
-  if (!searchContext || matchIndices.length === 0) return <>{text}</>
-
-  return (
-    <>
-      {renderHighlightedSegments(text, searchContext.query, matchIndices, currentMatchIndex, path)}
-    </>
-  )
-})
-
-interface StructuredNodeProps {
-  name: string
-  value: unknown
-  path: string
-  expandedPaths: Set<string>
-  onToggle: (path: string) => void
-  wrapText: boolean
-  currentMatchIndex: number
-  isError?: boolean
-}
-
-/**
- * Recursive node component for non-virtualized rendering.
- * Preserves exact original styling with border-left tree lines.
- */
-const StructuredNode = memo(function StructuredNode({
-  name,
-  value,
-  path,
-  expandedPaths,
-  onToggle,
-  wrapText,
-  currentMatchIndex,
-  isError = false,
-}: StructuredNodeProps) {
-  const searchContext = useContext(SearchContext)
-  const type = getTypeLabel(value)
-  const isPrimitiveValue = isPrimitive(value)
-  const isEmptyValue = !isPrimitiveValue && isEmpty(value)
-  const isExpanded = expandedPaths.has(path)
-
-  const handleToggle = useCallback(() => onToggle(path), [onToggle, path])
-
-  const handleKeyDown = useCallback(
-    (e: React.KeyboardEvent) => {
-      if (e.key === 'Enter' || e.key === ' ') {
-        e.preventDefault()
-        handleToggle()
-      }
-    },
-    [handleToggle]
-  )
-
-  const childEntries = useMemo(
-    () => (isPrimitiveValue || isEmptyValue ? [] : buildEntries(value, path)),
-    [value, isPrimitiveValue, isEmptyValue, path]
-  )
-
-  const collapsedSummary = useMemo(
-    () => (isPrimitiveValue ? null : getCollapsedSummary(value)),
-    [value, isPrimitiveValue]
-  )
-
-  const badgeVariant = isError ? 'red' : BADGE_VARIANTS[type]
-  const valueText = isPrimitiveValue ? formatPrimitive(value) : ''
-  const matchIndices = searchContext?.pathToMatchIndices.get(path) ?? EMPTY_MATCH_INDICES
-
-  return (
-    <div className='flex min-w-0 flex-col'>
-      <div
-        className={STYLES.row}
-        onClick={handleToggle}
-        onKeyDown={handleKeyDown}
-        role='button'
-        tabIndex={0}
-        aria-expanded={isExpanded}
-      >
-        <span className={cn(STYLES.keyName, isError && 'text-[var(--text-error)]')}>{name}</span>
-        <Badge variant={badgeVariant} className={STYLES.badge}>
-          {type}
-        </Badge>
-        {!isExpanded && collapsedSummary && (
-          <span className={STYLES.summary}>{collapsedSummary}</span>
-        )}
-        <ChevronDown className={cn(STYLES.chevron, !isExpanded && '-rotate-90')} />
-      </div>
-
-      {isExpanded && (
-        <div className={STYLES.indent}>
-          {isPrimitiveValue ? (
-            <div
-              className={cn(
-                STYLES.value,
-                wrapText ? '[word-break:break-word]' : 'whitespace-nowrap'
-              )}
-            >
-              <HighlightedText
-                text={valueText}
-                matchIndices={matchIndices}
-                path={path}
-                currentMatchIndex={currentMatchIndex}
-              />
-            </div>
-          ) : isEmptyValue ? (
-            <div className={STYLES.emptyValue}>{Array.isArray(value) ? '[]' : '{}'}</div>
-          ) : (
-            childEntries.map((entry) => (
-              <StructuredNode
-                key={entry.path}
-                name={entry.key}
-                value={entry.value}
-                path={entry.path}
-                expandedPaths={expandedPaths}
-                onToggle={onToggle}
-                wrapText={wrapText}
-                currentMatchIndex={currentMatchIndex}
-              />
-            ))
-          )}
-        </div>
-      )}
-    </div>
-  )
-})
-
-/**
- * Flattened row for virtualization.
- */
-interface FlatRow {
-  path: string
-  key: string
-  value: unknown
-  depth: number
-  type: 'header' | 'value' | 'empty'
-  valueType: ValueType
-  isExpanded: boolean
-  isError: boolean
-  collapsedSummary: string | null
-  displayText: string
-  matchIndices: number[]
-}
-
-/**
- * Flattens the tree into rows for virtualization.
- */
-function flattenTree(
-  data: unknown,
-  expandedPaths: Set<string>,
-  pathToMatchIndices: Map<string, number[]>,
-  isError: boolean
-): FlatRow[] {
-  const rows: FlatRow[] = []
-
-  if (isError) {
-    const errorText = extractErrorMessage(data)
-    const isExpanded = expandedPaths.has('root.error')
-
-    rows.push({
-      path: 'root.error',
-      key: 'error',
-      value: errorText,
-      depth: 0,
-      type: 'header',
-      valueType: 'string',
-      isExpanded,
-      isError: true,
-      collapsedSummary: null,
-      displayText: '',
-      matchIndices: [],
-    })
-
-    if (isExpanded) {
-      rows.push({
-        path: 'root.error.value',
-        key: '',
-        value: errorText,
-        depth: 1,
-        type: 'value',
-        valueType: 'string',
-        isExpanded: false,
-        isError: true,
-        collapsedSummary: null,
-        displayText: errorText,
-        matchIndices: pathToMatchIndices.get('root.error') ?? [],
-      })
-    }
-
-    return rows
-  }
-
-  function processNode(key: string, value: unknown, path: string, depth: number): void {
-    const valueType = getTypeLabel(value)
-    const isPrimitiveValue = isPrimitive(value)
-    const isEmptyValue = !isPrimitiveValue && isEmpty(value)
-    const isExpanded = expandedPaths.has(path)
-    const collapsedSummary = isPrimitiveValue ? null : getCollapsedSummary(value)
-
-    rows.push({
-      path,
-      key,
-      value,
-      depth,
-      type: 'header',
-      valueType,
-      isExpanded,
-      isError: false,
-      collapsedSummary,
-      displayText: '',
-      matchIndices: [],
-    })
-
-    if (isExpanded) {
-      if (isPrimitiveValue) {
-        rows.push({
-          path: `${path}.value`,
-          key: '',
-          value,
-          depth: depth + 1,
-          type: 'value',
-          valueType,
-          isExpanded: false,
-          isError: false,
-          collapsedSummary: null,
-          displayText: formatPrimitive(value),
-          matchIndices: pathToMatchIndices.get(path) ?? [],
-        })
-      } else if (isEmptyValue) {
-        rows.push({
-          path: `${path}.empty`,
-          key: '',
-          value,
-          depth: depth + 1,
-          type: 'empty',
-          valueType,
-          isExpanded: false,
-          isError: false,
-          collapsedSummary: null,
-          displayText: Array.isArray(value) ? '[]' : '{}',
-          matchIndices: [],
-        })
-      } else {
-        for (const entry of buildEntries(value, path)) {
-          processNode(entry.key, entry.value, entry.path, depth + 1)
-        }
-      }
-    }
-  }
-
-  if (isPrimitive(data)) {
-    processNode('value', data, 'root.value', 0)
-  } else if (data && typeof data === 'object') {
-    for (const entry of buildEntries(data, 'root')) {
-      processNode(entry.key, entry.value, entry.path, 0)
-    }
-  }
-
-  return rows
-}
-
-/**
- * Counts total visible rows for determining virtualization threshold.
- */
-function countVisibleRows(data: unknown, expandedPaths: Set<string>, isError: boolean): number {
-  if (isError) return expandedPaths.has('root.error') ? 2 : 1
-
-  let count = 0
-
-  function countNode(value: unknown, path: string): void {
-    count++
-    if (!expandedPaths.has(path)) return
-
-    if (isPrimitive(value) || isEmpty(value)) {
-      count++
-    } else {
-      for (const entry of buildEntries(value, path)) {
-        countNode(entry.value, entry.path)
-      }
-    }
-  }
-
-  if (isPrimitive(data)) {
-    countNode(data, 'root.value')
-  } else if (data && typeof data === 'object') {
-    for (const entry of buildEntries(data, 'root')) {
-      countNode(entry.value, entry.path)
-    }
-  }
-
-  return count
-}
-
-interface VirtualizedRowProps {
-  rows: FlatRow[]
-  onToggle: (path: string) => void
-  wrapText: boolean
-  searchQuery: string
-  currentMatchIndex: number
-}
-
-/**
- * Virtualized row component for large data sets.
- */
-function VirtualizedRow({ index, style, ...props }: RowComponentProps<VirtualizedRowProps>) {
-  const { rows, onToggle, wrapText, searchQuery, currentMatchIndex } = props
-  const row = rows[index]
-  const paddingLeft = CONFIG.BASE_PADDING + row.depth * CONFIG.INDENT_PER_LEVEL
-
-  if (row.type === 'header') {
-    const badgeVariant = row.isError ? 'red' : BADGE_VARIANTS[row.valueType]
-
-    return (
-      <div style={{ ...style, paddingLeft }} data-row-index={index}>
-        <div
-          className={STYLES.row}
-          onClick={() => onToggle(row.path)}
-          onKeyDown={(e) => {
-            if (e.key === 'Enter' || e.key === ' ') {
-              e.preventDefault()
-              onToggle(row.path)
-            }
-          }}
-          role='button'
-          tabIndex={0}
-          aria-expanded={row.isExpanded}
-        >
-          <span className={cn(STYLES.keyName, row.isError && 'text-[var(--text-error)]')}>
-            {row.key}
-          </span>
-          <Badge variant={badgeVariant} className={STYLES.badge}>
-            {row.valueType}
-          </Badge>
-          {!row.isExpanded && row.collapsedSummary && (
-            <span className={STYLES.summary}>{row.collapsedSummary}</span>
-          )}
-          <ChevronDown className={cn(STYLES.chevron, !row.isExpanded && '-rotate-90')} />
-        </div>
-      </div>
-    )
-  }
-
-  if (row.type === 'empty') {
-    return (
-      <div style={{ ...style, paddingLeft }} data-row-index={index}>
-        <div className={STYLES.emptyValue}>{row.displayText}</div>
-      </div>
-    )
-  }
-
-  return (
-    <div style={{ ...style, paddingLeft }} data-row-index={index}>
-      <div
-        className={cn(
-          STYLES.value,
-          row.isError && 'text-[var(--text-error)]',
-          wrapText ? '[word-break:break-word]' : 'whitespace-nowrap'
-        )}
-      >
-        {renderHighlightedSegments(
-          row.displayText,
-          searchQuery,
-          row.matchIndices,
-          currentMatchIndex,
-          row.path
-        )}
-      </div>
-    </div>
-  )
-}
-
-export interface StructuredOutputProps {
-  data: unknown
-  wrapText?: boolean
-  isError?: boolean
-  isRunning?: boolean
-  className?: string
-  searchQuery?: string
-  currentMatchIndex?: number
-  onMatchCountChange?: (count: number) => void
-  contentRef?: React.RefObject<HTMLDivElement | null>
-}
-
-/**
- * Renders structured data as nested collapsible blocks.
- * Uses virtualization for large data sets (>200 visible rows) while
- * preserving exact original styling for smaller data sets.
- */
-export const StructuredOutput = memo(function StructuredOutput({
-  data,
-  wrapText = true,
-  isError = false,
-  isRunning = false,
-  className,
-  searchQuery,
-  currentMatchIndex = 0,
-  onMatchCountChange,
-  contentRef,
-}: StructuredOutputProps) {
-  const [expandedPaths, setExpandedPaths] = useState<Set<string>>(() =>
-    computeInitialPaths(data, isError)
-  )
-  const prevDataRef = useRef(data)
-  const prevIsErrorRef = useRef(isError)
-  const internalRef = useRef<HTMLDivElement>(null)
-  const listRef = useListRef(null)
-  const [containerHeight, setContainerHeight] = useState(400)
-
-  const setContainerRef = useCallback(
-    (node: HTMLDivElement | null) => {
-      ;(internalRef as React.MutableRefObject<HTMLDivElement | null>).current = node
-      if (contentRef) {
-        ;(contentRef as React.MutableRefObject<HTMLDivElement | null>).current = node
-      }
-    },
-    [contentRef]
-  )
-
-  // Measure container height
-  useEffect(() => {
-    const container = internalRef.current?.parentElement
-    if (!container) return
-
-    const updateHeight = () => setContainerHeight(container.clientHeight)
-    updateHeight()
-
-    const resizeObserver = new ResizeObserver(updateHeight)
-    resizeObserver.observe(container)
-    return () => resizeObserver.disconnect()
-  }, [])
-
-  // Reset expanded paths when data changes
-  useEffect(() => {
-    if (prevDataRef.current !== data || prevIsErrorRef.current !== isError) {
-      prevDataRef.current = data
-      prevIsErrorRef.current = isError
-      setExpandedPaths(computeInitialPaths(data, isError))
-    }
-  }, [data, isError])
-
-  const allMatchPaths = useMemo(() => {
-    if (!searchQuery) return []
-    if (isError) {
-      const errorText = extractErrorMessage(data)
-      const count = findTextMatches(errorText, searchQuery).length
-      return Array(count).fill('root.error') as string[]
-    }
-    return collectAllMatchPaths(data, searchQuery, 'root')
-  }, [data, searchQuery, isError])
-
-  useEffect(() => {
-    onMatchCountChange?.(allMatchPaths.length)
-  }, [allMatchPaths.length, onMatchCountChange])
-
-  const pathToMatchIndices = useMemo(() => buildPathToIndicesMap(allMatchPaths), [allMatchPaths])
-
-  // Auto-expand to current match
-  useEffect(() => {
-    if (
-      allMatchPaths.length === 0 ||
-      currentMatchIndex < 0 ||
-      currentMatchIndex >= allMatchPaths.length
-    ) {
-      return
-    }
-
-    const currentPath = allMatchPaths[currentMatchIndex]
-    const pathsToExpand = [currentPath, ...getAncestorPaths(currentPath)]
-
-    setExpandedPaths((prev) => {
-      if (pathsToExpand.every((p) => prev.has(p))) return prev
-      const next = new Set(prev)
-      pathsToExpand.forEach((p) => next.add(p))
-      return next
-    })
-  }, [currentMatchIndex, allMatchPaths])
-
-  const handleToggle = useCallback((path: string) => {
-    setExpandedPaths((prev) => {
-      const next = new Set(prev)
-      if (next.has(path)) {
-        next.delete(path)
-      } else {
-        next.add(path)
-      }
-      return next
-    })
-  }, [])
-
-  const rootEntries = useMemo<NodeEntry[]>(() => {
-    if (isPrimitive(data)) return [{ key: 'value', value: data, path: 'root.value' }]
-    return buildEntries(data, 'root')
-  }, [data])
-
-  const searchContextValue = useMemo<SearchContextValue | null>(() => {
-    if (!searchQuery) return null
-    return { query: searchQuery, pathToMatchIndices }
-  }, [searchQuery, pathToMatchIndices])
-
-  const visibleRowCount = useMemo(
-    () => countVisibleRows(data, expandedPaths, isError),
-    [data, expandedPaths, isError]
-  )
-  const useVirtualization = visibleRowCount > CONFIG.VIRTUALIZATION_THRESHOLD
-
-  const flatRows = useMemo(() => {
-    if (!useVirtualization) return []
-    return flattenTree(data, expandedPaths, pathToMatchIndices, isError)
-  }, [data, expandedPaths, pathToMatchIndices, isError, useVirtualization])
-
-  // Scroll to match (virtualized)
-  useEffect(() => {
-    if (!useVirtualization || allMatchPaths.length === 0 || !listRef.current) return
-
-    const currentPath = allMatchPaths[currentMatchIndex]
-    const targetPath = currentPath.endsWith('.value') ? currentPath : `${currentPath}.value`
-    const rowIndex = flatRows.findIndex((r) => r.path === targetPath || r.path === currentPath)
-
-    if (rowIndex !== -1) {
-      listRef.current.scrollToRow({ index: rowIndex, align: 'center' })
-    }
-  }, [currentMatchIndex, allMatchPaths, flatRows, listRef, useVirtualization])
-
-  // Scroll to match (non-virtualized)
-  useEffect(() => {
-    if (useVirtualization || allMatchPaths.length === 0) return
-
-    const rafId = requestAnimationFrame(() => {
-      const match = internalRef.current?.querySelector(
-        `[data-match-index="${currentMatchIndex}"]`
-      ) as HTMLElement | null
-      match?.scrollIntoView({ block: 'center', behavior: 'smooth' })
-    })
-
-    return () => cancelAnimationFrame(rafId)
-  }, [currentMatchIndex, allMatchPaths.length, expandedPaths, useVirtualization])
-
-  const containerClass = cn('flex flex-col pl-[20px]', wrapText && 'overflow-x-hidden', className)
-  const virtualizedContainerClass = cn('relative', wrapText && 'overflow-x-hidden', className)
-  const listClass = wrapText ? 'overflow-x-hidden' : 'overflow-x-auto'
-
-  // Running state
-  if (isRunning && data === undefined) {
-    return (
-      <div ref={setContainerRef} className={containerClass}>
-        <div className={STYLES.row}>
-          <span className={STYLES.keyName}>running</span>
-          <Badge variant='green' className={STYLES.badge}>
-            Running
-          </Badge>
-        </div>
-      </div>
-    )
-  }
-
-  // Empty state
-  if (rootEntries.length === 0 && !isError) {
-    return (
-      <div ref={setContainerRef} className={containerClass}>
-        <span className={STYLES.emptyValue}>null</span>
-      </div>
-    )
-  }
-
-  // Virtualized rendering
-  if (useVirtualization) {
-    return (
-      <div
-        ref={setContainerRef}
-        className={virtualizedContainerClass}
-        style={{ height: containerHeight }}
-      >
-        <List
-          listRef={listRef}
-          defaultHeight={containerHeight}
-          rowCount={flatRows.length}
-          rowHeight={CONFIG.ROW_HEIGHT}
-          rowComponent={VirtualizedRow}
-          rowProps={{
-            rows: flatRows,
-            onToggle: handleToggle,
-            wrapText,
-            searchQuery: searchQuery ?? '',
-            currentMatchIndex,
-          }}
-          overscanCount={CONFIG.OVERSCAN_COUNT}
-          className={listClass}
-        />
-      </div>
-    )
-  }
-
-  // Non-virtualized rendering (preserves exact original styling)
-  if (isError) {
-    return (
-      <SearchContext.Provider value={searchContextValue}>
-        <div ref={setContainerRef} className={containerClass}>
-          <StructuredNode
-            name='error'
-            value={extractErrorMessage(data)}
-            path='root.error'
-            expandedPaths={expandedPaths}
-            onToggle={handleToggle}
-            wrapText={wrapText}
-            currentMatchIndex={currentMatchIndex}
-            isError
-          />
-        </div>
-      </SearchContext.Provider>
-    )
-  }
-
-  return (
-    <SearchContext.Provider value={searchContextValue}>
-      <div ref={setContainerRef} className={containerClass}>
-        {rootEntries.map((entry) => (
-          <StructuredNode
-            key={entry.path}
-            name={entry.key}
-            value={entry.value}
-            path={entry.path}
-            expandedPaths={expandedPaths}
-            onToggle={handleToggle}
-            wrapText={wrapText}
-            currentMatchIndex={currentMatchIndex}
-          />
-        ))}
-      </div>
-    </SearchContext.Provider>
-  )
-})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/output-panel/index.ts

@@ -1,4 +0,0 @@
-export { OutputContextMenu, type OutputContextMenuProps } from './components/output-context-menu'
-export { StructuredOutput, type StructuredOutputProps } from './components/structured-output'
-export type { OutputPanelProps } from './output-panel'
-export { OutputPanel } from './output-panel'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/output-panel/output-panel.tsx

@@ -1,643 +0,0 @@
-'use client'
-
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import clsx from 'clsx'
-import {
-  ArrowDown,
-  ArrowDownToLine,
-  ArrowUp,
-  Check,
-  Clipboard,
-  Database,
-  MoreHorizontal,
-  Palette,
-  Pause,
-  Search,
-  Trash2,
-  X,
-} from 'lucide-react'
-import Link from 'next/link'
-import {
-  Button,
-  Code,
-  Input,
-  Popover,
-  PopoverContent,
-  PopoverItem,
-  PopoverTrigger,
-  Tooltip,
-} from '@/components/emcn'
-import { FilterPopover } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/filter-popover'
-import { OutputContextMenu } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/output-panel/components/output-context-menu'
-import { StructuredOutput } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/output-panel/components/structured-output'
-import { ToggleButton } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/toggle-button'
-import type {
-  BlockInfo,
-  TerminalFilters,
-} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types'
-import { useContextMenu } from '@/app/workspace/[workspaceId]/w/components/sidebar/hooks'
-import { useCodeViewerFeatures } from '@/hooks/use-code-viewer'
-import type { ConsoleEntry } from '@/stores/terminal'
-import { useTerminalStore } from '@/stores/terminal'
-
-interface OutputCodeContentProps {
-  code: string
-  language: 'javascript' | 'json'
-  wrapText: boolean
-  searchQuery: string | undefined
-  currentMatchIndex: number
-  onMatchCountChange: (count: number) => void
-  contentRef: React.RefObject<HTMLDivElement | null>
-}
-
-const OutputCodeContent = React.memo(function OutputCodeContent({
-  code,
-  language,
-  wrapText,
-  searchQuery,
-  currentMatchIndex,
-  onMatchCountChange,
-  contentRef,
-}: OutputCodeContentProps) {
-  return (
-    <Code.Viewer
-      code={code}
-      showGutter
-      language={language}
-      className='m-0 min-h-full rounded-none border-0 bg-[var(--surface-1)] dark:bg-[var(--surface-1)]'
-      paddingLeft={8}
-      gutterStyle={{ backgroundColor: 'transparent' }}
-      wrapText={wrapText}
-      searchQuery={searchQuery}
-      currentMatchIndex={currentMatchIndex}
-      onMatchCountChange={onMatchCountChange}
-      contentRef={contentRef}
-      virtualized
-      showCollapseColumn={language === 'json'}
-    />
-  )
-})
-
-/**
- * Props for the OutputPanel component
- * Store-backed settings (wrapText, openOnRun, structuredView, outputPanelWidth)
- * are accessed directly from useTerminalStore to reduce prop drilling.
- */
-export interface OutputPanelProps {
-  selectedEntry: ConsoleEntry
-  handleOutputPanelResizeMouseDown: (e: React.MouseEvent) => void
-  handleHeaderClick: () => void
-  isExpanded: boolean
-  expandToLastHeight: () => void
-  showInput: boolean
-  setShowInput: (show: boolean) => void
-  hasInputData: boolean
-  isPlaygroundEnabled: boolean
-  shouldShowTrainingButton: boolean
-  isTraining: boolean
-  handleTrainingClick: (e: React.MouseEvent) => void
-  showCopySuccess: boolean
-  handleCopy: () => void
-  filteredEntries: ConsoleEntry[]
-  handleExportConsole: (e: React.MouseEvent) => void
-  hasActiveFilters: boolean
-  handleClearConsole: (e: React.MouseEvent) => void
-  shouldShowCodeDisplay: boolean
-  outputDataStringified: string
-  outputData: unknown
-  handleClearConsoleFromMenu: () => void
-  filters: TerminalFilters
-  toggleBlock: (blockId: string) => void
-  toggleStatus: (status: 'error' | 'info') => void
-  uniqueBlocks: BlockInfo[]
-}
-
-/**
- * Output panel component that manages its own search state.
- * Accesses store-backed settings directly to reduce prop drilling.
- */
-export const OutputPanel = React.memo(function OutputPanel({
-  selectedEntry,
-  handleOutputPanelResizeMouseDown,
-  handleHeaderClick,
-  isExpanded,
-  expandToLastHeight,
-  showInput,
-  setShowInput,
-  hasInputData,
-  isPlaygroundEnabled,
-  shouldShowTrainingButton,
-  isTraining,
-  handleTrainingClick,
-  showCopySuccess,
-  handleCopy,
-  filteredEntries,
-  handleExportConsole,
-  hasActiveFilters,
-  handleClearConsole,
-  shouldShowCodeDisplay,
-  outputDataStringified,
-  outputData,
-  handleClearConsoleFromMenu,
-  filters,
-  toggleBlock,
-  toggleStatus,
-  uniqueBlocks,
-}: OutputPanelProps) {
-  // Access store-backed settings directly to reduce prop drilling
-  const outputPanelWidth = useTerminalStore((state) => state.outputPanelWidth)
-  const wrapText = useTerminalStore((state) => state.wrapText)
-  const setWrapText = useTerminalStore((state) => state.setWrapText)
-  const openOnRun = useTerminalStore((state) => state.openOnRun)
-  const setOpenOnRun = useTerminalStore((state) => state.setOpenOnRun)
-  const structuredView = useTerminalStore((state) => state.structuredView)
-  const setStructuredView = useTerminalStore((state) => state.setStructuredView)
-
-  const outputContentRef = useRef<HTMLDivElement>(null)
-  const [filtersOpen, setFiltersOpen] = useState(false)
-  const [outputOptionsOpen, setOutputOptionsOpen] = useState(false)
-  const {
-    isSearchActive: isOutputSearchActive,
-    searchQuery: outputSearchQuery,
-    setSearchQuery: setOutputSearchQuery,
-    matchCount,
-    currentMatchIndex,
-    activateSearch: activateOutputSearch,
-    closeSearch: closeOutputSearch,
-    goToNextMatch,
-    goToPreviousMatch,
-    handleMatchCountChange,
-    searchInputRef: outputSearchInputRef,
-  } = useCodeViewerFeatures({
-    contentRef: outputContentRef,
-    externalWrapText: wrapText,
-    onWrapTextChange: setWrapText,
-  })
-
-  // Context menu state for output panel
-  const [hasSelection, setHasSelection] = useState(false)
-  const [storedSelectionText, setStoredSelectionText] = useState('')
-  const {
-    isOpen: isOutputMenuOpen,
-    position: outputMenuPosition,
-    menuRef: outputMenuRef,
-    handleContextMenu: handleOutputContextMenu,
-    closeMenu: closeOutputMenu,
-  } = useContextMenu()
-
-  const handleOutputPanelContextMenu = useCallback(
-    (e: React.MouseEvent) => {
-      const selection = window.getSelection()
-      const selectionText = selection?.toString() || ''
-      setStoredSelectionText(selectionText)
-      setHasSelection(selectionText.length > 0)
-      handleOutputContextMenu(e)
-    },
-    [handleOutputContextMenu]
-  )
-
-  const handleCopySelection = useCallback(() => {
-    if (storedSelectionText) {
-      navigator.clipboard.writeText(storedSelectionText)
-    }
-  }, [storedSelectionText])
-
-  // Memoized callbacks to avoid inline arrow functions
-  const handleToggleStructuredView = useCallback(() => {
-    setStructuredView(!structuredView)
-  }, [structuredView, setStructuredView])
-
-  const handleToggleWrapText = useCallback(() => {
-    setWrapText(!wrapText)
-  }, [wrapText, setWrapText])
-
-  const handleToggleOpenOnRun = useCallback(() => {
-    setOpenOnRun(!openOnRun)
-  }, [openOnRun, setOpenOnRun])
-
-  const handleCopyClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation()
-      handleCopy()
-    },
-    [handleCopy]
-  )
-
-  const handleSearchClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation()
-      activateOutputSearch()
-    },
-    [activateOutputSearch]
-  )
-
-  const handleCloseSearchClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation()
-      closeOutputSearch()
-    },
-    [closeOutputSearch]
-  )
-
-  const handleOutputButtonClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation()
-      if (!isExpanded) {
-        expandToLastHeight()
-      }
-      if (showInput) setShowInput(false)
-    },
-    [isExpanded, expandToLastHeight, showInput, setShowInput]
-  )
-
-  const handleInputButtonClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation()
-      if (!isExpanded) {
-        expandToLastHeight()
-      }
-      setShowInput(true)
-    },
-    [isExpanded, expandToLastHeight, setShowInput]
-  )
-
-  const handleToggleButtonClick = useCallback(
-    (e: React.MouseEvent) => {
-      e.stopPropagation()
-      handleHeaderClick()
-    },
-    [handleHeaderClick]
-  )
-
-  /**
-   * Track text selection state for context menu.
-   * Skip updates when the context menu is open to prevent the selection
-   * state from changing mid-click (which would disable the copy button).
-   */
-  useEffect(() => {
-    const handleSelectionChange = () => {
-      if (isOutputMenuOpen) return
-
-      const selection = window.getSelection()
-      setHasSelection(Boolean(selection && selection.toString().length > 0))
-    }
-
-    document.addEventListener('selectionchange', handleSelectionChange)
-    return () => document.removeEventListener('selectionchange', handleSelectionChange)
-  }, [isOutputMenuOpen])
-
-  // Memoize the search query for structured output to avoid re-renders
-  const structuredSearchQuery = useMemo(
-    () => (isOutputSearchActive ? outputSearchQuery : undefined),
-    [isOutputSearchActive, outputSearchQuery]
-  )
-
-  return (
-    <>
-      <div
-        className='absolute top-0 right-0 bottom-0 flex flex-col border-[var(--border)] border-l bg-[var(--surface-1)]'
-        style={{ width: `${outputPanelWidth}px` }}
-      >
-        {/* Horizontal Resize Handle */}
-        <div
-          className='-ml-[4px] absolute top-0 bottom-0 left-0 z-20 w-[8px] cursor-ew-resize'
-          onMouseDown={handleOutputPanelResizeMouseDown}
-          role='separator'
-          aria-label='Resize output panel'
-          aria-orientation='vertical'
-        />
-
-        {/* Header */}
-        <div
-          className='group flex h-[30px] flex-shrink-0 cursor-pointer items-center justify-between bg-[var(--surface-1)] pr-[16px] pl-[10px]'
-          onClick={handleHeaderClick}
-        >
-          <div className='flex items-center'>
-            <Button
-              variant='ghost'
-              className={clsx(
-                'px-[8px] py-[6px] text-[12px]',
-                !showInput ? '!text-[var(--text-primary)]' : '!text-[var(--text-tertiary)]'
-              )}
-              onClick={handleOutputButtonClick}
-              aria-label='Show output'
-            >
-              Output
-            </Button>
-            {hasInputData && (
-              <Button
-                variant='ghost'
-                className={clsx(
-                  'px-[8px] py-[6px] text-[12px]',
-                  showInput ? '!text-[var(--text-primary)]' : '!text-[var(--text-tertiary)]'
-                )}
-                onClick={handleInputButtonClick}
-                aria-label='Show input'
-              >
-                Input
-              </Button>
-            )}
-          </div>
-          <div className='flex flex-shrink-0 items-center gap-[8px]'>
-            {/* Unified filter popover */}
-            {filteredEntries.length > 0 && (
-              <FilterPopover
-                open={filtersOpen}
-                onOpenChange={setFiltersOpen}
-                filters={filters}
-                toggleStatus={toggleStatus}
-                toggleBlock={toggleBlock}
-                uniqueBlocks={uniqueBlocks}
-                hasActiveFilters={hasActiveFilters}
-              />
-            )}
-
-            {isOutputSearchActive ? (
-              <Tooltip.Root>
-                <Tooltip.Trigger asChild>
-                  <Button
-                    variant='ghost'
-                    onClick={handleCloseSearchClick}
-                    aria-label='Close search'
-                    className='!p-1.5 -m-1.5'
-                  >
-                    <X className='h-[12px] w-[12px]' />
-                  </Button>
-                </Tooltip.Trigger>
-                <Tooltip.Content>
-                  <span>Close search</span>
-                </Tooltip.Content>
-              </Tooltip.Root>
-            ) : (
-              <Tooltip.Root>
-                <Tooltip.Trigger asChild>
-                  <Button
-                    variant='ghost'
-                    onClick={handleSearchClick}
-                    aria-label='Search in output'
-                    className='!p-1.5 -m-1.5'
-                  >
-                    <Search className='h-[12px] w-[12px]' />
-                  </Button>
-                </Tooltip.Trigger>
-                <Tooltip.Content>
-                  <span>Search</span>
-                </Tooltip.Content>
-              </Tooltip.Root>
-            )}
-
-            {isPlaygroundEnabled && (
-              <Tooltip.Root>
-                <Tooltip.Trigger asChild>
-                  <Link href='/playground'>
-                    <Button
-                      variant='ghost'
-                      aria-label='Component Playground'
-                      className='!p-1.5 -m-1.5'
-                    >
-                      <Palette className='h-[12px] w-[12px]' />
-                    </Button>
-                  </Link>
-                </Tooltip.Trigger>
-                <Tooltip.Content>
-                  <span>Component Playground</span>
-                </Tooltip.Content>
-              </Tooltip.Root>
-            )}
-
-            {shouldShowTrainingButton && (
-              <Tooltip.Root>
-                <Tooltip.Trigger asChild>
-                  <Button
-                    variant='ghost'
-                    onClick={handleTrainingClick}
-                    aria-label={isTraining ? 'Stop training' : 'Train Copilot'}
-                    className={clsx(
-                      '!p-1.5 -m-1.5',
-                      isTraining && 'text-orange-600 dark:text-orange-400'
-                    )}
-                  >
-                    {isTraining ? (
-                      <Pause className='h-[12px] w-[12px]' />
-                    ) : (
-                      <Database className='h-[12px] w-[12px]' />
-                    )}
-                  </Button>
-                </Tooltip.Trigger>
-                <Tooltip.Content>
-                  <span>{isTraining ? 'Stop Training' : 'Train Copilot'}</span>
-                </Tooltip.Content>
-              </Tooltip.Root>
-            )}
-
-            <Tooltip.Root>
-              <Tooltip.Trigger asChild>
-                <Button
-                  variant='ghost'
-                  onClick={handleCopyClick}
-                  aria-label='Copy output'
-                  className='!p-1.5 -m-1.5'
-                >
-                  {showCopySuccess ? (
-                    <Check className='h-[12px] w-[12px]' />
-                  ) : (
-                    <Clipboard className='h-[12px] w-[12px]' />
-                  )}
-                </Button>
-              </Tooltip.Trigger>
-              <Tooltip.Content>
-                <span>{showCopySuccess ? 'Copied' : 'Copy output'}</span>
-              </Tooltip.Content>
-            </Tooltip.Root>
-            {filteredEntries.length > 0 && (
-              <>
-                <Tooltip.Root>
-                  <Tooltip.Trigger asChild>
-                    <Button
-                      variant='ghost'
-                      onClick={handleExportConsole}
-                      aria-label='Download console CSV'
-                      className='!p-1.5 -m-1.5'
-                    >
-                      <ArrowDownToLine className='h-3 w-3' />
-                    </Button>
-                  </Tooltip.Trigger>
-                  <Tooltip.Content>
-                    <span>Download CSV</span>
-                  </Tooltip.Content>
-                </Tooltip.Root>
-                <Tooltip.Root>
-                  <Tooltip.Trigger asChild>
-                    <Button
-                      variant='ghost'
-                      onClick={handleClearConsole}
-                      aria-label='Clear console'
-                      className='!p-1.5 -m-1.5'
-                    >
-                      <Trash2 className='h-3 w-3' />
-                    </Button>
-                  </Tooltip.Trigger>
-                  <Tooltip.Content>
-                    <Tooltip.Shortcut keys='⌘D'>Clear console</Tooltip.Shortcut>
-                  </Tooltip.Content>
-                </Tooltip.Root>
-              </>
-            )}
-            <Popover open={outputOptionsOpen} onOpenChange={setOutputOptionsOpen} size='sm'>
-              <PopoverTrigger asChild>
-                <Button
-                  variant='ghost'
-                  onClick={(e) => e.stopPropagation()}
-                  aria-label='Terminal options'
-                  className='!p-1.5 -m-1.5'
-                >
-                  <MoreHorizontal className='h-3.5 w-3.5' />
-                </Button>
-              </PopoverTrigger>
-              <PopoverContent
-                side='bottom'
-                align='end'
-                sideOffset={4}
-                collisionPadding={0}
-                onClick={(e) => e.stopPropagation()}
-                style={{ minWidth: '140px', maxWidth: '160px' }}
-                className='gap-[2px]'
-              >
-                <PopoverItem
-                  active={structuredView}
-                  showCheck={structuredView}
-                  onClick={handleToggleStructuredView}
-                >
-                  <span>Structured view</span>
-                </PopoverItem>
-                <PopoverItem active={wrapText} showCheck={wrapText} onClick={handleToggleWrapText}>
-                  <span>Wrap text</span>
-                </PopoverItem>
-                <PopoverItem
-                  active={openOnRun}
-                  showCheck={openOnRun}
-                  onClick={handleToggleOpenOnRun}
-                >
-                  <span>Open on run</span>
-                </PopoverItem>
-              </PopoverContent>
-            </Popover>
-            <ToggleButton isExpanded={isExpanded} onClick={handleToggleButtonClick} />
-          </div>
-        </div>
-
-        {/* Search Overlay */}
-        {isOutputSearchActive && (
-          <div
-            className='absolute top-[30px] right-[8px] z-30 flex h-[34px] items-center gap-[6px] rounded-b-[4px] border border-[var(--border)] border-t-0 bg-[var(--surface-1)] px-[6px] shadow-sm'
-            onClick={(e) => e.stopPropagation()}
-            data-toolbar-root
-            data-search-active='true'
-          >
-            <Input
-              ref={outputSearchInputRef}
-              type='text'
-              value={outputSearchQuery}
-              onChange={(e) => setOutputSearchQuery(e.target.value)}
-              placeholder='Search...'
-              className='mr-[2px] h-[23px] w-[94px] text-[12px]'
-            />
-            <span
-              className={clsx(
-                'w-[58px] font-medium text-[11px]',
-                matchCount > 0 ? 'text-[var(--text-secondary)]' : 'text-[var(--text-tertiary)]'
-              )}
-            >
-              {matchCount > 0 ? `${currentMatchIndex + 1}/${matchCount}` : 'No results'}
-            </span>
-            <Button
-              variant='ghost'
-              onClick={goToPreviousMatch}
-              aria-label='Previous match'
-              className='!p-1.5 -m-1.5'
-              disabled={matchCount === 0}
-            >
-              <ArrowUp className='h-[12px] w-[12px]' />
-            </Button>
-            <Button
-              variant='ghost'
-              onClick={goToNextMatch}
-              aria-label='Next match'
-              className='!p-1.5 -m-1.5'
-              disabled={matchCount === 0}
-            >
-              <ArrowDown className='h-[12px] w-[12px]' />
-            </Button>
-            <Button
-              variant='ghost'
-              onClick={closeOutputSearch}
-              aria-label='Close search'
-              className='!p-1.5 -m-1.5'
-            >
-              <X className='h-[12px] w-[12px]' />
-            </Button>
-          </div>
-        )}
-
-        {/* Content */}
-        <div
-          className={clsx('flex-1 overflow-y-auto', !wrapText && 'overflow-x-auto')}
-          onContextMenu={handleOutputPanelContextMenu}
-        >
-          {shouldShowCodeDisplay ? (
-            <OutputCodeContent
-              code={selectedEntry.input.code}
-              language={(selectedEntry.input.language as 'javascript' | 'json') || 'javascript'}
-              wrapText={wrapText}
-              searchQuery={structuredSearchQuery}
-              currentMatchIndex={currentMatchIndex}
-              onMatchCountChange={handleMatchCountChange}
-              contentRef={outputContentRef}
-            />
-          ) : structuredView ? (
-            <StructuredOutput
-              data={outputData}
-              wrapText={wrapText}
-              isError={!showInput && Boolean(selectedEntry.error)}
-              isRunning={!showInput && Boolean(selectedEntry.isRunning)}
-              className='min-h-full'
-              searchQuery={structuredSearchQuery}
-              currentMatchIndex={currentMatchIndex}
-              onMatchCountChange={handleMatchCountChange}
-              contentRef={outputContentRef}
-            />
-          ) : (
-            <OutputCodeContent
-              code={outputDataStringified}
-              language='json'
-              wrapText={wrapText}
-              searchQuery={structuredSearchQuery}
-              currentMatchIndex={currentMatchIndex}
-              onMatchCountChange={handleMatchCountChange}
-              contentRef={outputContentRef}
-            />
-          )}
-        </div>
-      </div>
-
-      {/* Output Panel Context Menu */}
-      <OutputContextMenu
-        isOpen={isOutputMenuOpen}
-        position={outputMenuPosition}
-        menuRef={outputMenuRef}
-        onClose={closeOutputMenu}
-        onCopySelection={handleCopySelection}
-        onCopyAll={handleCopy}
-        onSearch={activateOutputSearch}
-        structuredView={structuredView}
-        onToggleStructuredView={handleToggleStructuredView}
-        wrapText={wrapText}
-        onToggleWrap={handleToggleWrapText}
-        openOnRun={openOnRun}
-        onToggleOpenOnRun={handleToggleOpenOnRun}
-        onClearConsole={handleClearConsoleFromMenu}
-        hasSelection={hasSelection}
-      />
-    </>
-  )
-})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/status-display/index.ts

@@ -1 +0,0 @@
-export { RunningBadge, StatusDisplay, type StatusDisplayProps } from './status-display'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/status-display/status-display.tsx

@@ -1,43 +0,0 @@
-'use client'
-
-import { memo } from 'react'
-import { Badge } from '@/components/emcn'
-import { BADGE_STYLE } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types'
-
-/**
- * Running badge component - displays a consistent "Running" indicator
- */
-export const RunningBadge = memo(function RunningBadge() {
-  return (
-    <Badge variant='green' className={BADGE_STYLE}>
-      Running
-    </Badge>
-  )
-})
-
-/**
- * Props for StatusDisplay component
- */
-export interface StatusDisplayProps {
-  isRunning: boolean
-  isCanceled: boolean
-  formattedDuration: string
-}
-
-/**
- * Reusable status display for terminal rows.
- * Shows Running badge, 'canceled' text, or formatted duration.
- */
-export const StatusDisplay = memo(function StatusDisplay({
-  isRunning,
-  isCanceled,
-  formattedDuration,
-}: StatusDisplayProps) {
-  if (isRunning) {
-    return <RunningBadge />
-  }
-  if (isCanceled) {
-    return <>canceled</>
-  }
-  return <>{formattedDuration}</>
-})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/toggle-button/index.ts

@@ -1 +0,0 @@
-export { ToggleButton, type ToggleButtonProps } from './toggle-button'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/components/toggle-button/toggle-button.tsx

@@ -1,33 +0,0 @@
-'use client'
-
-import type React from 'react'
-import { memo } from 'react'
-import clsx from 'clsx'
-import { ChevronDown } from 'lucide-react'
-import { Button } from '@/components/emcn'
-
-export interface ToggleButtonProps {
-  isExpanded: boolean
-  onClick: (e: React.MouseEvent) => void
-}
-
-/**
- * Toggle button component for terminal expand/collapse
- */
-export const ToggleButton = memo(function ToggleButton({ isExpanded, onClick }: ToggleButtonProps) {
-  return (
-    <Button
-      variant='ghost'
-      className='!p-1.5 -m-1.5'
-      onClick={onClick}
-      aria-label='Toggle terminal'
-    >
-      <ChevronDown
-        className={clsx(
-          'h-3.5 w-3.5 flex-shrink-0 transition-transform duration-100',
-          !isExpanded && 'rotate-180'
-        )}
-      />
-    </Button>
-  )
-})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/hooks/index.ts

@@ -1,4 +1,3 @@
-export type { SortConfig, SortDirection, SortField, TerminalFilters } from '../types'
 export { useOutputPanelResize } from './use-output-panel-resize'
 export { useTerminalFilters } from './use-terminal-filters'
 export { useTerminalResize } from './use-terminal-resize'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/hooks/use-output-panel-resize.ts

@@ -1,7 +1,9 @@
 import { useCallback, useEffect, useState } from 'react'
-import { OUTPUT_PANEL_WIDTH, TERMINAL_BLOCK_COLUMN_WIDTH } from '@/stores/constants'
+import { OUTPUT_PANEL_WIDTH } from '@/stores/constants'
 import { useTerminalStore } from '@/stores/terminal'
 
+const BLOCK_COLUMN_WIDTH = 240
+
 export function useOutputPanelResize() {
   const setOutputPanelWidth = useTerminalStore((state) => state.setOutputPanelWidth)
   const [isResizing, setIsResizing] = useState(false)
@@ -23,7 +25,7 @@ export function useOutputPanelResize() {
 
       const newWidth = window.innerWidth - e.clientX - panelWidth
       const terminalWidth = window.innerWidth - sidebarWidth - panelWidth
-      const maxWidth = terminalWidth - TERMINAL_BLOCK_COLUMN_WIDTH
+      const maxWidth = terminalWidth - BLOCK_COLUMN_WIDTH
       const clampedWidth = Math.max(OUTPUT_PANEL_WIDTH.MIN, Math.min(newWidth, maxWidth))
 
       setOutputPanelWidth(clampedWidth)

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/hooks/use-terminal-filters.ts

@@ -1,10 +1,26 @@
 import { useCallback, useMemo, useState } from 'react'
-import type {
-  SortConfig,
-  TerminalFilters,
-} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types'
 import type { ConsoleEntry } from '@/stores/terminal'
 
+/**
+ * Sort configuration
+ */
+export type SortField = 'timestamp'
+export type SortDirection = 'asc' | 'desc'
+
+export interface SortConfig {
+  field: SortField
+  direction: SortDirection
+}
+
+/**
+ * Filter configuration state
+ */
+export interface TerminalFilters {
+  blockIds: Set<string>
+  statuses: Set<'error' | 'info'>
+  runIds: Set<string>
+}
+
 /**
  * Custom hook to manage terminal filters and sorting.
  * Provides filter state, sort state, and filtering/sorting logic for console entries.
@@ -15,6 +31,7 @@ export function useTerminalFilters() {
   const [filters, setFilters] = useState<TerminalFilters>({
     blockIds: new Set(),
     statuses: new Set(),
+    runIds: new Set(),
   })
 
   const [sortConfig, setSortConfig] = useState<SortConfig>({
@@ -52,6 +69,21 @@ export function useTerminalFilters() {
     })
   }, [])
 
+  /**
+   * Toggles a run ID filter
+   */
+  const toggleRunId = useCallback((runId: string) => {
+    setFilters((prev) => {
+      const newRunIds = new Set(prev.runIds)
+      if (newRunIds.has(runId)) {
+        newRunIds.delete(runId)
+      } else {
+        newRunIds.add(runId)
+      }
+      return { ...prev, runIds: newRunIds }
+    })
+  }, [])
+
   /**
    * Toggles sort direction between ascending and descending
    */
@@ -69,6 +101,7 @@ export function useTerminalFilters() {
     setFilters({
       blockIds: new Set(),
       statuses: new Set(),
+      runIds: new Set(),
     })
   }, [])
 
@@ -76,7 +109,7 @@ export function useTerminalFilters() {
    * Checks if any filters are active
    */
   const hasActiveFilters = useMemo(() => {
-    return filters.blockIds.size > 0 || filters.statuses.size > 0
+    return filters.blockIds.size > 0 || filters.statuses.size > 0 || filters.runIds.size > 0
   }, [filters])
 
   /**
@@ -101,6 +134,14 @@ export function useTerminalFilters() {
             if (!hasStatus) return false
           }
 
+          // Run ID filter
+          if (
+            filters.runIds.size > 0 &&
+            (!entry.executionId || !filters.runIds.has(entry.executionId))
+          ) {
+            return false
+          }
+
           return true
         })
       }
@@ -123,6 +164,7 @@ export function useTerminalFilters() {
     sortConfig,
     toggleBlock,
     toggleStatus,
+    toggleRunId,
     toggleSort,
     clearFilters,
     hasActiveFilters,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/types.ts

@@ -1,64 +0,0 @@
-/**
- * Terminal filter configuration state
- */
-export interface TerminalFilters {
-  blockIds: Set<string>
-  statuses: Set<'error' | 'info'>
-}
-
-/**
- * Context menu position for positioning floating menus
- */
-export interface ContextMenuPosition {
-  x: number
-  y: number
-}
-
-/**
- * Sort field options for terminal entries
- */
-export type SortField = 'timestamp'
-
-/**
- * Sort direction options
- */
-export type SortDirection = 'asc' | 'desc'
-
-/**
- * Sort configuration for terminal entries
- */
-export interface SortConfig {
-  field: SortField
-  direction: SortDirection
-}
-
-/**
- * Status type for console entries
- */
-export type EntryStatus = 'error' | 'info'
-
-/**
- * Block information for filters
- */
-export interface BlockInfo {
-  blockId: string
-  blockName: string
-  blockType: string
-}
-
-/**
- * Common row styling classes for terminal components
- */
-export const ROW_STYLES = {
-  base: 'group flex cursor-pointer items-center justify-between gap-[8px] rounded-[8px] px-[6px]',
-  selected: 'bg-[var(--surface-6)] dark:bg-[var(--surface-5)]',
-  hover: 'hover:bg-[var(--surface-6)] dark:hover:bg-[var(--surface-5)]',
-  nested:
-    'mt-[2px] ml-[3px] flex min-w-0 flex-col gap-[2px] border-[var(--border)] border-l pl-[9px]',
-  iconButton: '!p-1.5 -m-1.5',
-} as const
-
-/**
- * Common badge styling for status badges
- */
-export const BADGE_STYLE = 'rounded-[4px] px-[4px] py-[0px] text-[11px]'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/terminal/utils.ts

@@ -1,452 +0,0 @@
-import type React from 'react'
-import { RepeatIcon, SplitIcon } from 'lucide-react'
-import { getBlock } from '@/blocks'
-import { TERMINAL_BLOCK_COLUMN_WIDTH } from '@/stores/constants'
-import type { ConsoleEntry } from '@/stores/terminal'
-
-/**
- * Subflow colors matching the subflow tool configs
- */
-const SUBFLOW_COLORS = {
-  loop: '#2FB3FF',
-  parallel: '#FEE12B',
-} as const
-
-/**
- * Retrieves the icon component for a given block type
- */
-export function getBlockIcon(
-  blockType: string
-): React.ComponentType<{ className?: string }> | null {
-  const blockConfig = getBlock(blockType)
-
-  if (blockConfig?.icon) {
-    return blockConfig.icon
-  }
-
-  if (blockType === 'loop') {
-    return RepeatIcon
-  }
-
-  if (blockType === 'parallel') {
-    return SplitIcon
-  }
-
-  return null
-}
-
-/**
- * Gets the background color for a block type
- */
-export function getBlockColor(blockType: string): string {
-  const blockConfig = getBlock(blockType)
-  if (blockConfig?.bgColor) {
-    return blockConfig.bgColor
-  }
-  // Use proper subflow colors matching the toolbar configs
-  if (blockType === 'loop') {
-    return SUBFLOW_COLORS.loop
-  }
-  if (blockType === 'parallel') {
-    return SUBFLOW_COLORS.parallel
-  }
-  return '#6b7280'
-}
-
-/**
- * Formats duration from milliseconds to readable format
- */
-export function formatDuration(ms?: number): string {
-  if (ms === undefined || ms === null) return '-'
-  if (ms < 1000) return `${ms}ms`
-  return `${(ms / 1000).toFixed(2)}s`
-}
-
-/**
- * Determines if a keyboard event originated from a text-editable element
- */
-export function isEventFromEditableElement(e: KeyboardEvent): boolean {
-  const target = e.target as HTMLElement | null
-  if (!target) return false
-
-  const isEditable = (el: HTMLElement | null): boolean => {
-    if (!el) return false
-    if (el instanceof HTMLInputElement) return true
-    if (el instanceof HTMLTextAreaElement) return true
-    if ((el as HTMLElement).isContentEditable) return true
-    const role = el.getAttribute('role')
-    if (role === 'textbox' || role === 'combobox') return true
-    return false
-  }
-
-  let el: HTMLElement | null = target
-  while (el) {
-    if (isEditable(el)) return true
-    el = el.parentElement
-  }
-  return false
-}
-
-/**
- * Checks if a block type is a subflow (loop or parallel)
- */
-export function isSubflowBlockType(blockType: string): boolean {
-  const lower = blockType?.toLowerCase() || ''
-  return lower === 'loop' || lower === 'parallel'
-}
-
-/**
- * Node type for the tree structure
- */
-export type EntryNodeType = 'block' | 'subflow' | 'iteration'
-
-/**
- * Entry node for tree structure - represents a block, subflow, or iteration
- */
-export interface EntryNode {
-  /** The console entry (for blocks) or synthetic entry (for subflows/iterations) */
-  entry: ConsoleEntry
-  /** Child nodes */
-  children: EntryNode[]
-  /** Node type */
-  nodeType: EntryNodeType
-  /** Iteration info for iteration nodes */
-  iterationInfo?: {
-    current: number
-    total?: number
-  }
-}
-
-/**
- * Execution group interface for grouping entries by execution
- */
-export interface ExecutionGroup {
-  executionId: string
-  startTime: string
-  endTime: string
-  startTimeMs: number
-  endTimeMs: number
-  duration: number
-  status: 'success' | 'error'
-  /** Flat list of entries (legacy, kept for filters) */
-  entries: ConsoleEntry[]
-  /** Tree structure of entry nodes for nested display */
-  entryTree: EntryNode[]
-}
-
-/**
- * Iteration group for grouping blocks within the same iteration
- */
-interface IterationGroup {
-  iterationType: string
-  iterationCurrent: number
-  iterationTotal?: number
-  blocks: ConsoleEntry[]
-  startTimeMs: number
-}
-
-/**
- * Builds a tree structure from flat entries.
- * Groups iteration entries by (iterationType, iterationCurrent), showing all blocks
- * that executed within each iteration.
- * Sorts by start time to ensure chronological order.
- */
-function buildEntryTree(entries: ConsoleEntry[]): EntryNode[] {
-  // Separate regular blocks from iteration entries
-  const regularBlocks: ConsoleEntry[] = []
-  const iterationEntries: ConsoleEntry[] = []
-
-  for (const entry of entries) {
-    if (entry.iterationType && entry.iterationCurrent !== undefined) {
-      iterationEntries.push(entry)
-    } else {
-      regularBlocks.push(entry)
-    }
-  }
-
-  // Group iteration entries by (iterationType, iterationCurrent)
-  const iterationGroupsMap = new Map<string, IterationGroup>()
-  for (const entry of iterationEntries) {
-    const key = `${entry.iterationType}-${entry.iterationCurrent}`
-    let group = iterationGroupsMap.get(key)
-    const entryStartMs = new Date(entry.startedAt || entry.timestamp).getTime()
-
-    if (!group) {
-      group = {
-        iterationType: entry.iterationType!,
-        iterationCurrent: entry.iterationCurrent!,
-        iterationTotal: entry.iterationTotal,
-        blocks: [],
-        startTimeMs: entryStartMs,
-      }
-      iterationGroupsMap.set(key, group)
-    } else {
-      // Update start time to earliest
-      if (entryStartMs < group.startTimeMs) {
-        group.startTimeMs = entryStartMs
-      }
-      // Update total if available
-      if (entry.iterationTotal !== undefined) {
-        group.iterationTotal = entry.iterationTotal
-      }
-    }
-    group.blocks.push(entry)
-  }
-
-  // Sort blocks within each iteration by start time ascending (oldest first, top-down)
-  for (const group of iterationGroupsMap.values()) {
-    group.blocks.sort((a, b) => {
-      const aStart = new Date(a.startedAt || a.timestamp).getTime()
-      const bStart = new Date(b.startedAt || b.timestamp).getTime()
-      return aStart - bStart
-    })
-  }
-
-  // Group iterations by iterationType to create subflow parents
-  const subflowGroups = new Map<string, IterationGroup[]>()
-  for (const group of iterationGroupsMap.values()) {
-    const type = group.iterationType
-    let groups = subflowGroups.get(type)
-    if (!groups) {
-      groups = []
-      subflowGroups.set(type, groups)
-    }
-    groups.push(group)
-  }
-
-  // Sort iterations within each subflow by iteration number
-  for (const groups of subflowGroups.values()) {
-    groups.sort((a, b) => a.iterationCurrent - b.iterationCurrent)
-  }
-
-  // Build subflow nodes with iteration children
-  const subflowNodes: EntryNode[] = []
-  for (const [iterationType, iterationGroups] of subflowGroups.entries()) {
-    // Calculate subflow timing from all its iterations
-    const firstIteration = iterationGroups[0]
-    const allBlocks = iterationGroups.flatMap((g) => g.blocks)
-    const subflowStartMs = Math.min(
-      ...allBlocks.map((b) => new Date(b.startedAt || b.timestamp).getTime())
-    )
-    const subflowEndMs = Math.max(
-      ...allBlocks.map((b) => new Date(b.endedAt || b.timestamp).getTime())
-    )
-    const totalDuration = allBlocks.reduce((sum, b) => sum + (b.durationMs || 0), 0)
-
-    // Create synthetic subflow parent entry
-    const syntheticSubflow: ConsoleEntry = {
-      id: `subflow-${iterationType}-${firstIteration.blocks[0]?.executionId || 'unknown'}`,
-      timestamp: new Date(subflowStartMs).toISOString(),
-      workflowId: firstIteration.blocks[0]?.workflowId || '',
-      blockId: `${iterationType}-container`,
-      blockName: iterationType.charAt(0).toUpperCase() + iterationType.slice(1),
-      blockType: iterationType,
-      executionId: firstIteration.blocks[0]?.executionId,
-      startedAt: new Date(subflowStartMs).toISOString(),
-      endedAt: new Date(subflowEndMs).toISOString(),
-      durationMs: totalDuration,
-      success: !allBlocks.some((b) => b.error),
-    }
-
-    // Build iteration child nodes
-    const iterationNodes: EntryNode[] = iterationGroups.map((iterGroup) => {
-      // Create synthetic iteration entry
-      const iterBlocks = iterGroup.blocks
-      const iterStartMs = Math.min(
-        ...iterBlocks.map((b) => new Date(b.startedAt || b.timestamp).getTime())
-      )
-      const iterEndMs = Math.max(
-        ...iterBlocks.map((b) => new Date(b.endedAt || b.timestamp).getTime())
-      )
-      const iterDuration = iterBlocks.reduce((sum, b) => sum + (b.durationMs || 0), 0)
-
-      const syntheticIteration: ConsoleEntry = {
-        id: `iteration-${iterationType}-${iterGroup.iterationCurrent}-${iterBlocks[0]?.executionId || 'unknown'}`,
-        timestamp: new Date(iterStartMs).toISOString(),
-        workflowId: iterBlocks[0]?.workflowId || '',
-        blockId: `iteration-${iterGroup.iterationCurrent}`,
-        blockName: `Iteration ${iterGroup.iterationCurrent}${iterGroup.iterationTotal !== undefined ? ` / ${iterGroup.iterationTotal}` : ''}`,
-        blockType: iterationType,
-        executionId: iterBlocks[0]?.executionId,
-        startedAt: new Date(iterStartMs).toISOString(),
-        endedAt: new Date(iterEndMs).toISOString(),
-        durationMs: iterDuration,
-        success: !iterBlocks.some((b) => b.error),
-        iterationCurrent: iterGroup.iterationCurrent,
-        iterationTotal: iterGroup.iterationTotal,
-        iterationType: iterationType as 'loop' | 'parallel',
-      }
-
-      // Block nodes within this iteration
-      const blockNodes: EntryNode[] = iterBlocks.map((block) => ({
-        entry: block,
-        children: [],
-        nodeType: 'block' as const,
-      }))
-
-      return {
-        entry: syntheticIteration,
-        children: blockNodes,
-        nodeType: 'iteration' as const,
-        iterationInfo: {
-          current: iterGroup.iterationCurrent,
-          total: iterGroup.iterationTotal,
-        },
-      }
-    })
-
-    subflowNodes.push({
-      entry: syntheticSubflow,
-      children: iterationNodes,
-      nodeType: 'subflow' as const,
-    })
-  }
-
-  // Build nodes for regular blocks
-  const regularNodes: EntryNode[] = regularBlocks.map((entry) => ({
-    entry,
-    children: [],
-    nodeType: 'block' as const,
-  }))
-
-  // Combine all nodes and sort by start time ascending (oldest first, top-down)
-  const allNodes = [...subflowNodes, ...regularNodes]
-  allNodes.sort((a, b) => {
-    const aStart = new Date(a.entry.startedAt || a.entry.timestamp).getTime()
-    const bStart = new Date(b.entry.startedAt || b.entry.timestamp).getTime()
-    return aStart - bStart
-  })
-
-  return allNodes
-}
-
-/**
- * Groups console entries by execution ID and builds a tree structure.
- * Pre-computes timestamps for efficient sorting.
- */
-export function groupEntriesByExecution(entries: ConsoleEntry[]): ExecutionGroup[] {
-  const groups = new Map<
-    string,
-    { meta: Omit<ExecutionGroup, 'entryTree'>; entries: ConsoleEntry[] }
-  >()
-
-  for (const entry of entries) {
-    const execId = entry.executionId || entry.id
-
-    const entryStartTime = entry.startedAt || entry.timestamp
-    const entryEndTime = entry.endedAt || entry.timestamp
-    const entryStartMs = new Date(entryStartTime).getTime()
-    const entryEndMs = new Date(entryEndTime).getTime()
-
-    let group = groups.get(execId)
-
-    if (!group) {
-      group = {
-        meta: {
-          executionId: execId,
-          startTime: entryStartTime,
-          endTime: entryEndTime,
-          startTimeMs: entryStartMs,
-          endTimeMs: entryEndMs,
-          duration: 0,
-          status: 'success',
-          entries: [],
-        },
-        entries: [],
-      }
-      groups.set(execId, group)
-    } else {
-      // Update timing bounds
-      if (entryStartMs < group.meta.startTimeMs) {
-        group.meta.startTime = entryStartTime
-        group.meta.startTimeMs = entryStartMs
-      }
-      if (entryEndMs > group.meta.endTimeMs) {
-        group.meta.endTime = entryEndTime
-        group.meta.endTimeMs = entryEndMs
-      }
-    }
-
-    // Check for errors
-    if (entry.error) {
-      group.meta.status = 'error'
-    }
-
-    group.entries.push(entry)
-  }
-
-  // Build tree structure for each group
-  const result: ExecutionGroup[] = []
-  for (const group of groups.values()) {
-    group.meta.duration = group.meta.endTimeMs - group.meta.startTimeMs
-    group.meta.entries = group.entries
-    result.push({
-      ...group.meta,
-      entryTree: buildEntryTree(group.entries),
-    })
-  }
-
-  // Sort by start time descending (newest first)
-  result.sort((a, b) => b.startTimeMs - a.startTimeMs)
-
-  return result
-}
-
-/**
- * Flattens entry tree into display order for keyboard navigation
- */
-export function flattenEntryTree(nodes: EntryNode[]): ConsoleEntry[] {
-  const result: ConsoleEntry[] = []
-  for (const node of nodes) {
-    result.push(node.entry)
-    if (node.children.length > 0) {
-      result.push(...flattenEntryTree(node.children))
-    }
-  }
-  return result
-}
-
-/**
- * Block entry with parent tracking for navigation
- */
-export interface NavigableBlockEntry {
-  entry: ConsoleEntry
-  executionId: string
-  /** IDs of parent nodes (subflows, iterations) that contain this block */
-  parentNodeIds: string[]
-}
-
-/**
- * Flattens entry tree to only include actual block entries (not subflows/iterations).
- * Also tracks parent node IDs for auto-expanding when navigating.
- */
-export function flattenBlockEntriesOnly(
-  nodes: EntryNode[],
-  executionId: string,
-  parentIds: string[] = []
-): NavigableBlockEntry[] {
-  const result: NavigableBlockEntry[] = []
-  for (const node of nodes) {
-    if (node.nodeType === 'block') {
-      result.push({
-        entry: node.entry,
-        executionId,
-        parentNodeIds: parentIds,
-      })
-    }
-    if (node.children.length > 0) {
-      const newParentIds = node.nodeType !== 'block' ? [...parentIds, node.entry.id] : parentIds
-      result.push(...flattenBlockEntriesOnly(node.children, executionId, newParentIds))
-    }
-  }
-  return result
-}
-
-/**
- * Terminal height configuration constants
- */
-export const TERMINAL_CONFIG = {
-  NEAR_MIN_THRESHOLD: 40,
-  BLOCK_COLUMN_WIDTH_PX: TERMINAL_BLOCK_COLUMN_WIDTH,
-  HEADER_TEXT_CLASS: 'font-medium text-[var(--text-tertiary)] text-[12px]',
-} as const

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

@@ -1,7 +1,6 @@
 import { useCallback, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import { useQueryClient } from '@tanstack/react-query'
-import { readSSEStream } from '@/lib/core/utils/sse'
 import type { GenerationType } from '@/blocks/types'
 import { subscriptionKeys } from '@/hooks/queries/subscription'
 
@@ -185,10 +184,52 @@ export function useWand({
           throw new Error('Response body is null')
         }
 
-        const accumulatedContent = await readSSEStream(response.body, {
-          onChunk: onStreamChunk,
-          signal: abortControllerRef.current?.signal,
-        })
+        const reader = response.body.getReader()
+        const decoder = new TextDecoder()
+        let accumulatedContent = ''
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+
+            const chunk = decoder.decode(value)
+            const lines = chunk.split('\n\n')
+
+            for (const line of lines) {
+              if (line.startsWith('data: ')) {
+                const lineData = line.substring(6)
+
+                if (lineData === '[DONE]') {
+                  continue
+                }
+
+                try {
+                  const data = JSON.parse(lineData)
+
+                  if (data.error) {
+                    throw new Error(data.error)
+                  }
+
+                  if (data.chunk) {
+                    accumulatedContent += data.chunk
+                    if (onStreamChunk) {
+                      onStreamChunk(data.chunk)
+                    }
+                  }
+
+                  if (data.done) {
+                    break
+                  }
+                } catch (parseError) {
+                  logger.debug('Failed to parse SSE line', { line, parseError })
+                }
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock()
+        }
 
         if (accumulatedContent) {
           onGeneratedContent(accumulatedContent)

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

@@ -15,16 +15,13 @@ import {
   TriggerUtils,
 } from '@/lib/workflows/triggers/triggers'
 import { useCurrentWorkflow } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-current-workflow'
-import { getBlock } from '@/blocks'
-import type { SerializableExecutionState } from '@/executor/execution/types'
-import type { BlockLog, BlockState, ExecutionResult, StreamingExecution } from '@/executor/types'
+import type { BlockLog, ExecutionResult, StreamingExecution } from '@/executor/types'
 import { hasExecutionResult } from '@/executor/utils/errors'
 import { coerceValue } from '@/executor/utils/start-block'
 import { subscriptionKeys } from '@/hooks/queries/subscription'
 import { useExecutionStream } from '@/hooks/use-execution-stream'
 import { WorkflowValidationError } from '@/serializer'
 import { useExecutionStore } from '@/stores/execution'
-import { useNotificationStore } from '@/stores/notifications'
 import { useVariablesStore } from '@/stores/panel'
 import { useEnvironmentStore } from '@/stores/settings/environment'
 import { type ConsoleEntry, useTerminalConsoleStore } from '@/stores/terminal'
@@ -84,8 +81,7 @@ export function useWorkflowExecution() {
   const queryClient = useQueryClient()
   const currentWorkflow = useCurrentWorkflow()
   const { activeWorkflowId, workflows } = useWorkflowRegistry()
-  const { toggleConsole, addConsole, updateConsole, cancelRunningEntries } =
-    useTerminalConsoleStore()
+  const { toggleConsole, addConsole } = useTerminalConsoleStore()
   const { getAllVariables } = useEnvironmentStore()
   const { getVariablesByWorkflowId, variables } = useVariablesStore()
   const {
@@ -102,15 +98,11 @@ export function useWorkflowExecution() {
     setActiveBlocks,
     setBlockRunStatus,
     setEdgeRunStatus,
-    setLastExecutionSnapshot,
-    getLastExecutionSnapshot,
-    clearLastExecutionSnapshot,
   } = useExecutionStore()
   const [executionResult, setExecutionResult] = useState<ExecutionResult | null>(null)
   const executionStream = useExecutionStream()
   const currentChatExecutionIdRef = useRef<string | null>(null)
   const isViewingDiff = useWorkflowDiffStore((state) => state.isShowingDiff)
-  const addNotification = useNotificationStore((state) => state.addNotification)
 
   /**
    * Validates debug state before performing debug operations
@@ -676,8 +668,7 @@ export function useWorkflowExecution() {
     onStream?: (se: StreamingExecution) => Promise<void>,
     executionId?: string,
     onBlockComplete?: (blockId: string, output: any) => Promise<void>,
-    overrideTriggerType?: 'chat' | 'manual' | 'api',
-    stopAfterBlockId?: string
+    overrideTriggerType?: 'chat' | 'manual' | 'api'
   ): Promise<ExecutionResult | StreamingExecution> => {
     // Use diff workflow for execution when available, regardless of canvas view state
     const executionWorkflowState = null as {
@@ -876,8 +867,6 @@ export function useWorkflowExecution() {
     if (activeWorkflowId) {
       logger.info('Using server-side executor')
 
-      const executionId = uuidv4()
-
       let executionResult: ExecutionResult = {
         success: false,
         output: {},
@@ -887,8 +876,6 @@ export function useWorkflowExecution() {
       const activeBlocksSet = new Set<string>()
       const streamedContent = new Map<string, string>()
       const accumulatedBlockLogs: BlockLog[] = []
-      const accumulatedBlockStates = new Map<string, BlockState>()
-      const executedBlockIds = new Set<string>()
 
       // Execute the workflow
       try {
@@ -900,7 +887,6 @@ export function useWorkflowExecution() {
           triggerType: overrideTriggerType || 'manual',
           useDraftState: true,
           isClientSession: true,
-          stopAfterBlockId,
           workflowStateOverride: executionWorkflowState
             ? {
                 blocks: executionWorkflowState.blocks,
@@ -924,49 +910,24 @@ export function useWorkflowExecution() {
               incomingEdges.forEach((edge) => {
                 setEdgeRunStatus(edge.id, 'success')
               })
-
-              // Add entry to terminal immediately with isRunning=true
-              const startedAt = new Date().toISOString()
-              addConsole({
-                input: {},
-                output: undefined,
-                success: undefined,
-                durationMs: undefined,
-                startedAt,
-                endedAt: undefined,
-                workflowId: activeWorkflowId,
-                blockId: data.blockId,
-                executionId,
-                blockName: data.blockName || 'Unknown Block',
-                blockType: data.blockType || 'unknown',
-                isRunning: true,
-                // Pass through iteration context for subflow grouping
-                iterationCurrent: data.iterationCurrent,
-                iterationTotal: data.iterationTotal,
-                iterationType: data.iterationType,
-              })
             },
 
             onBlockCompleted: (data) => {
               logger.info('onBlockCompleted received:', { data })
 
               activeBlocksSet.delete(data.blockId)
+              // Create a new Set to trigger React re-render
               setActiveBlocks(new Set(activeBlocksSet))
+
+              // Track successful block execution in run path
               setBlockRunStatus(data.blockId, 'success')
 
-              executedBlockIds.add(data.blockId)
-              accumulatedBlockStates.set(data.blockId, {
-                output: data.output,
-                executed: true,
-                executionTime: data.durationMs,
-              })
-
-              const isContainerBlock = data.blockType === 'loop' || data.blockType === 'parallel'
-              if (isContainerBlock) return
+              // Edges already tracked in onBlockStarted, no need to track again
 
               const startedAt = new Date(Date.now() - data.durationMs).toISOString()
               const endedAt = new Date().toISOString()
 
+              // Accumulate block log for the execution result
               accumulatedBlockLogs.push({
                 blockId: data.blockId,
                 blockName: data.blockName || 'Unknown Block',
@@ -979,23 +940,24 @@ export function useWorkflowExecution() {
                 endedAt,
               })
 
-              // Update existing console entry (created in onBlockStarted) with completion data
-              updateConsole(
-                data.blockId,
-                {
-                  input: data.input || {},
-                  replaceOutput: data.output,
-                  success: true,
-                  durationMs: data.durationMs,
-                  endedAt,
-                  isRunning: false,
-                  // Pass through iteration context for subflow grouping
-                  iterationCurrent: data.iterationCurrent,
-                  iterationTotal: data.iterationTotal,
-                  iterationType: data.iterationType,
-                },
-                executionId
-              )
+              // Add to console
+              addConsole({
+                input: data.input || {},
+                output: data.output,
+                success: true,
+                durationMs: data.durationMs,
+                startedAt,
+                endedAt,
+                workflowId: activeWorkflowId,
+                blockId: data.blockId,
+                executionId: executionId || uuidv4(),
+                blockName: data.blockName || 'Unknown Block',
+                blockType: data.blockType || 'unknown',
+                // Pass through iteration context for console pills
+                iterationCurrent: data.iterationCurrent,
+                iterationTotal: data.iterationTotal,
+                iterationType: data.iterationType,
+              })
 
               // Call onBlockComplete callback if provided
               if (onBlockComplete) {
@@ -1030,24 +992,25 @@ export function useWorkflowExecution() {
                 endedAt,
               })
 
-              // Update existing console entry (created in onBlockStarted) with error data
-              updateConsole(
-                data.blockId,
-                {
-                  input: data.input || {},
-                  replaceOutput: {},
-                  success: false,
-                  error: data.error,
-                  durationMs: data.durationMs,
-                  endedAt,
-                  isRunning: false,
-                  // Pass through iteration context for subflow grouping
-                  iterationCurrent: data.iterationCurrent,
-                  iterationTotal: data.iterationTotal,
-                  iterationType: data.iterationType,
-                },
-                executionId
-              )
+              // Add error to console
+              addConsole({
+                input: data.input || {},
+                output: {},
+                success: false,
+                error: data.error,
+                durationMs: data.durationMs,
+                startedAt,
+                endedAt,
+                workflowId: activeWorkflowId,
+                blockId: data.blockId,
+                executionId: executionId || uuidv4(),
+                blockName: data.blockName,
+                blockType: data.blockType,
+                // Pass through iteration context for console pills
+                iterationCurrent: data.iterationCurrent,
+                iterationTotal: data.iterationTotal,
+                iterationType: data.iterationType,
+              })
             },
 
             onStreamChunk: (data) => {
@@ -1093,53 +1056,6 @@ export function useWorkflowExecution() {
                 },
                 logs: accumulatedBlockLogs,
               }
-
-              // Add trigger block to executed blocks so downstream blocks can use run-from-block
-              if (data.success && startBlockId) {
-                executedBlockIds.add(startBlockId)
-              }
-
-              if (data.success && activeWorkflowId) {
-                if (stopAfterBlockId) {
-                  const existingSnapshot = getLastExecutionSnapshot(activeWorkflowId)
-                  const mergedBlockStates = {
-                    ...(existingSnapshot?.blockStates || {}),
-                    ...Object.fromEntries(accumulatedBlockStates),
-                  }
-                  const mergedExecutedBlocks = new Set([
-                    ...(existingSnapshot?.executedBlocks || []),
-                    ...executedBlockIds,
-                  ])
-                  const snapshot: SerializableExecutionState = {
-                    blockStates: mergedBlockStates,
-                    executedBlocks: Array.from(mergedExecutedBlocks),
-                    blockLogs: [...(existingSnapshot?.blockLogs || []), ...accumulatedBlockLogs],
-                    decisions: existingSnapshot?.decisions || { router: {}, condition: {} },
-                    completedLoops: existingSnapshot?.completedLoops || [],
-                    activeExecutionPath: Array.from(mergedExecutedBlocks),
-                  }
-                  setLastExecutionSnapshot(activeWorkflowId, snapshot)
-                  logger.info('Merged execution snapshot after run-until-block', {
-                    workflowId: activeWorkflowId,
-                    newBlocksExecuted: executedBlockIds.size,
-                    totalExecutedBlocks: mergedExecutedBlocks.size,
-                  })
-                } else {
-                  const snapshot: SerializableExecutionState = {
-                    blockStates: Object.fromEntries(accumulatedBlockStates),
-                    executedBlocks: Array.from(executedBlockIds),
-                    blockLogs: accumulatedBlockLogs,
-                    decisions: { router: {}, condition: {} },
-                    completedLoops: [],
-                    activeExecutionPath: Array.from(executedBlockIds),
-                  }
-                  setLastExecutionSnapshot(activeWorkflowId, snapshot)
-                  logger.info('Stored execution snapshot for run-from-block', {
-                    workflowId: activeWorkflowId,
-                    executedBlocksCount: executedBlockIds.size,
-                  })
-                }
-              }
             },
 
             onExecutionError: (data) => {
@@ -1173,7 +1089,7 @@ export function useWorkflowExecution() {
                   endedAt: new Date().toISOString(),
                   workflowId: activeWorkflowId,
                   blockId: 'validation',
-                  executionId,
+                  executionId: executionId || uuidv4(),
                   blockName: 'Workflow Validation',
                   blockType: 'validation',
                 })
@@ -1442,11 +1358,6 @@ export function useWorkflowExecution() {
     // Mark current chat execution as superseded so its cleanup won't affect new executions
     currentChatExecutionIdRef.current = null
 
-    // Mark all running entries as canceled in the terminal
-    if (activeWorkflowId) {
-      cancelRunningEntries(activeWorkflowId)
-    }
-
     // Reset execution state - this triggers chat stream cleanup via useEffect in chat.tsx
     setIsExecuting(false)
     setIsDebugging(false)
@@ -1463,334 +1374,8 @@ export function useWorkflowExecution() {
     setIsExecuting,
     setIsDebugging,
     setActiveBlocks,
-    activeWorkflowId,
-    cancelRunningEntries,
   ])
 
-  /**
-   * Handles running workflow from a specific block using cached outputs
-   */
-  const handleRunFromBlock = useCallback(
-    async (blockId: string, workflowId: string) => {
-      const snapshot = getLastExecutionSnapshot(workflowId)
-      const workflowEdges = useWorkflowStore.getState().edges
-      const incomingEdges = workflowEdges.filter((edge) => edge.target === blockId)
-      const isTriggerBlock = incomingEdges.length === 0
-
-      // Check if each source block is either executed OR is a trigger block (triggers don't need prior execution)
-      const isSourceSatisfied = (sourceId: string) => {
-        if (snapshot?.executedBlocks.includes(sourceId)) return true
-        // Check if source is a trigger (has no incoming edges itself)
-        const sourceIncomingEdges = workflowEdges.filter((edge) => edge.target === sourceId)
-        return sourceIncomingEdges.length === 0
-      }
-
-      // Non-trigger blocks need a snapshot to exist (so upstream outputs are available)
-      if (!snapshot && !isTriggerBlock) {
-        logger.error('No execution snapshot available for run-from-block', { workflowId, blockId })
-        return
-      }
-
-      const dependenciesSatisfied =
-        isTriggerBlock || incomingEdges.every((edge) => isSourceSatisfied(edge.source))
-
-      if (!dependenciesSatisfied) {
-        logger.error('Upstream dependencies not satisfied for run-from-block', {
-          workflowId,
-          blockId,
-        })
-        return
-      }
-
-      // For trigger blocks, always use empty snapshot to prevent stale data from different
-      // execution paths from being resolved. For non-trigger blocks, use the existing snapshot.
-      const emptySnapshot: SerializableExecutionState = {
-        blockStates: {},
-        executedBlocks: [],
-        blockLogs: [],
-        decisions: { router: {}, condition: {} },
-        completedLoops: [],
-        activeExecutionPath: [],
-      }
-      const effectiveSnapshot: SerializableExecutionState = isTriggerBlock
-        ? emptySnapshot
-        : snapshot || emptySnapshot
-
-      // Extract mock payload for trigger blocks
-      let workflowInput: any
-      if (isTriggerBlock) {
-        const workflowBlocks = useWorkflowStore.getState().blocks
-        const mergedStates = mergeSubblockState(workflowBlocks, workflowId)
-        const candidates = resolveStartCandidates(mergedStates, { execution: 'manual' })
-        const candidate = candidates.find((c) => c.blockId === blockId)
-
-        if (candidate) {
-          if (triggerNeedsMockPayload(candidate)) {
-            workflowInput = extractTriggerMockPayload(candidate)
-          } else if (
-            candidate.path === StartBlockPath.SPLIT_API ||
-            candidate.path === StartBlockPath.SPLIT_INPUT ||
-            candidate.path === StartBlockPath.UNIFIED
-          ) {
-            const inputFormatValue = candidate.block.subBlocks?.inputFormat?.value
-            if (Array.isArray(inputFormatValue)) {
-              const testInput: Record<string, any> = {}
-              inputFormatValue.forEach((field: any) => {
-                if (field && typeof field === 'object' && field.name && field.value !== undefined) {
-                  testInput[field.name] = coerceValue(field.type, field.value)
-                }
-              })
-              if (Object.keys(testInput).length > 0) {
-                workflowInput = testInput
-              }
-            }
-          }
-        } else {
-          // Fallback: block is trigger by position but not classified as start candidate
-          const block = mergedStates[blockId]
-          if (block) {
-            const blockConfig = getBlock(block.type)
-            const hasTriggers = blockConfig?.triggers?.available?.length
-
-            if (hasTriggers || block.triggerMode) {
-              workflowInput = extractTriggerMockPayload({
-                blockId,
-                block,
-                path: StartBlockPath.EXTERNAL_TRIGGER,
-              })
-            }
-          }
-        }
-      }
-
-      setIsExecuting(true)
-      const executionId = uuidv4()
-      const accumulatedBlockLogs: BlockLog[] = []
-      const accumulatedBlockStates = new Map<string, BlockState>()
-      const executedBlockIds = new Set<string>()
-      const activeBlocksSet = new Set<string>()
-
-      try {
-        await executionStream.executeFromBlock({
-          workflowId,
-          startBlockId: blockId,
-          sourceSnapshot: effectiveSnapshot,
-          input: workflowInput,
-          callbacks: {
-            onBlockStarted: (data) => {
-              activeBlocksSet.add(data.blockId)
-              setActiveBlocks(new Set(activeBlocksSet))
-
-              const incomingEdges = workflowEdges.filter((edge) => edge.target === data.blockId)
-              incomingEdges.forEach((edge) => {
-                setEdgeRunStatus(edge.id, 'success')
-              })
-            },
-
-            onBlockCompleted: (data) => {
-              activeBlocksSet.delete(data.blockId)
-              setActiveBlocks(new Set(activeBlocksSet))
-
-              setBlockRunStatus(data.blockId, 'success')
-
-              executedBlockIds.add(data.blockId)
-              accumulatedBlockStates.set(data.blockId, {
-                output: data.output,
-                executed: true,
-                executionTime: data.durationMs,
-              })
-
-              const isContainerBlock = data.blockType === 'loop' || data.blockType === 'parallel'
-              if (isContainerBlock) return
-
-              const startedAt = new Date(Date.now() - data.durationMs).toISOString()
-              const endedAt = new Date().toISOString()
-
-              accumulatedBlockLogs.push({
-                blockId: data.blockId,
-                blockName: data.blockName || 'Unknown Block',
-                blockType: data.blockType || 'unknown',
-                input: data.input || {},
-                output: data.output,
-                success: true,
-                durationMs: data.durationMs,
-                startedAt,
-                endedAt,
-              })
-
-              addConsole({
-                input: data.input || {},
-                output: data.output,
-                success: true,
-                durationMs: data.durationMs,
-                startedAt,
-                endedAt,
-                workflowId,
-                blockId: data.blockId,
-                executionId,
-                blockName: data.blockName || 'Unknown Block',
-                blockType: data.blockType || 'unknown',
-                iterationCurrent: data.iterationCurrent,
-                iterationTotal: data.iterationTotal,
-                iterationType: data.iterationType,
-              })
-            },
-
-            onBlockError: (data) => {
-              activeBlocksSet.delete(data.blockId)
-              setActiveBlocks(new Set(activeBlocksSet))
-
-              setBlockRunStatus(data.blockId, 'error')
-
-              const startedAt = new Date(Date.now() - data.durationMs).toISOString()
-              const endedAt = new Date().toISOString()
-
-              accumulatedBlockLogs.push({
-                blockId: data.blockId,
-                blockName: data.blockName || 'Unknown Block',
-                blockType: data.blockType || 'unknown',
-                input: data.input || {},
-                output: {},
-                success: false,
-                error: data.error,
-                durationMs: data.durationMs,
-                startedAt,
-                endedAt,
-              })
-
-              addConsole({
-                input: data.input || {},
-                output: {},
-                success: false,
-                error: data.error,
-                durationMs: data.durationMs,
-                startedAt,
-                endedAt,
-                workflowId,
-                blockId: data.blockId,
-                executionId,
-                blockName: data.blockName,
-                blockType: data.blockType,
-                iterationCurrent: data.iterationCurrent,
-                iterationTotal: data.iterationTotal,
-                iterationType: data.iterationType,
-              })
-            },
-
-            onExecutionCompleted: (data) => {
-              if (data.success) {
-                // Add the start block (trigger) to executed blocks
-                executedBlockIds.add(blockId)
-
-                const mergedBlockStates: Record<string, BlockState> = {
-                  ...effectiveSnapshot.blockStates,
-                }
-                for (const [bId, state] of accumulatedBlockStates) {
-                  mergedBlockStates[bId] = state
-                }
-
-                const mergedExecutedBlocks = new Set([
-                  ...effectiveSnapshot.executedBlocks,
-                  ...executedBlockIds,
-                ])
-
-                const updatedSnapshot: SerializableExecutionState = {
-                  ...effectiveSnapshot,
-                  blockStates: mergedBlockStates,
-                  executedBlocks: Array.from(mergedExecutedBlocks),
-                  blockLogs: [...effectiveSnapshot.blockLogs, ...accumulatedBlockLogs],
-                  activeExecutionPath: Array.from(mergedExecutedBlocks),
-                }
-                setLastExecutionSnapshot(workflowId, updatedSnapshot)
-              }
-            },
-
-            onExecutionError: (data) => {
-              const isWorkflowModified =
-                data.error?.includes('Block not found in workflow') ||
-                data.error?.includes('Upstream dependency not executed')
-
-              if (isWorkflowModified) {
-                clearLastExecutionSnapshot(workflowId)
-                addNotification({
-                  level: 'error',
-                  message:
-                    'Workflow was modified. Run the workflow again to enable running from block.',
-                  workflowId,
-                })
-              } else {
-                addNotification({
-                  level: 'error',
-                  message: data.error || 'Run from block failed',
-                  workflowId,
-                })
-              }
-            },
-          },
-        })
-      } catch (error) {
-        if ((error as Error).name !== 'AbortError') {
-          logger.error('Run-from-block failed:', error)
-        }
-      } finally {
-        setIsExecuting(false)
-        setActiveBlocks(new Set())
-      }
-    },
-    [
-      getLastExecutionSnapshot,
-      setLastExecutionSnapshot,
-      clearLastExecutionSnapshot,
-      setIsExecuting,
-      setActiveBlocks,
-      setBlockRunStatus,
-      setEdgeRunStatus,
-      addNotification,
-      addConsole,
-      executionStream,
-    ]
-  )
-
-  /**
-   * Handles running workflow until a specific block (stops after that block completes)
-   */
-  const handleRunUntilBlock = useCallback(
-    async (blockId: string, workflowId: string) => {
-      if (!workflowId || workflowId !== activeWorkflowId) {
-        logger.error('Invalid workflow ID for run-until-block', { workflowId, activeWorkflowId })
-        return
-      }
-
-      logger.info('Starting run-until-block execution', { workflowId, stopAfterBlockId: blockId })
-
-      setExecutionResult(null)
-      setIsExecuting(true)
-
-      const executionId = uuidv4()
-      try {
-        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 {
-        setIsExecuting(false)
-        setIsDebugging(false)
-        setActiveBlocks(new Set())
-      }
-    },
-    [activeWorkflowId, setExecutionResult, setIsExecuting, setIsDebugging, setActiveBlocks]
-  )
-
   return {
     isExecuting,
     isDebugging,
@@ -1801,7 +1386,5 @@ export function useWorkflowExecution() {
     handleResumeDebug,
     handleCancelDebug,
     handleCancelExecution,
-    handleRunFromBlock,
-    handleRunUntilBlock,
   }
 }

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

@@ -47,7 +47,6 @@ import {
   useCurrentWorkflow,
   useNodeUtilities,
   useShiftSelectionLock,
-  useWorkflowExecution,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks'
 import {
   calculateContainerDimensions,
@@ -303,8 +302,6 @@ const WorkflowContent = React.memo(() => {
 
   const showTrainingModal = useCopilotTrainingStore((state) => state.showModal)
 
-  const { handleRunFromBlock, handleRunUntilBlock } = useWorkflowExecution()
-
   const snapToGridSize = useSnapToGridSize()
   const snapToGrid = snapToGridSize > 0
 
@@ -736,16 +733,13 @@ const WorkflowContent = React.memo(() => {
     [collaborativeBatchAddBlocks, setSelectedEdges, setPendingSelection]
   )
 
-  const { activeBlockIds, pendingBlocks, isDebugging, isExecuting, getLastExecutionSnapshot } =
-    useExecutionStore(
-      useShallow((state) => ({
-        activeBlockIds: state.activeBlockIds,
-        pendingBlocks: state.pendingBlocks,
-        isDebugging: state.isDebugging,
-        isExecuting: state.isExecuting,
-        getLastExecutionSnapshot: state.getLastExecutionSnapshot,
-      }))
-    )
+  const { activeBlockIds, pendingBlocks, isDebugging } = useExecutionStore(
+    useShallow((state) => ({
+      activeBlockIds: state.activeBlockIds,
+      pendingBlocks: state.pendingBlocks,
+      isDebugging: state.isDebugging,
+    }))
+  )
 
   const [dragStartParentId, setDragStartParentId] = useState<string | null>(null)
 
@@ -1108,50 +1102,6 @@ const WorkflowContent = React.memo(() => {
     }
   }, [contextMenuBlocks])
 
-  const handleContextRunFromBlock = useCallback(() => {
-    if (contextMenuBlocks.length !== 1) return
-    const blockId = contextMenuBlocks[0].id
-    handleRunFromBlock(blockId, workflowIdParam)
-  }, [contextMenuBlocks, workflowIdParam, handleRunFromBlock])
-
-  const handleContextRunUntilBlock = useCallback(() => {
-    if (contextMenuBlocks.length !== 1) return
-    const blockId = contextMenuBlocks[0].id
-    handleRunUntilBlock(blockId, workflowIdParam)
-  }, [contextMenuBlocks, workflowIdParam, handleRunUntilBlock])
-
-  const runFromBlockState = useMemo(() => {
-    if (contextMenuBlocks.length !== 1) {
-      return { canRun: false, reason: undefined }
-    }
-    const block = contextMenuBlocks[0]
-    const snapshot = getLastExecutionSnapshot(workflowIdParam)
-    const incomingEdges = edges.filter((edge) => edge.target === block.id)
-    const isTriggerBlock = incomingEdges.length === 0
-
-    // Check if each source block is either executed OR is a trigger block (triggers don't need prior execution)
-    const isSourceSatisfied = (sourceId: string) => {
-      if (snapshot?.executedBlocks.includes(sourceId)) return true
-      // Check if source is a trigger (has no incoming edges itself)
-      const sourceIncomingEdges = edges.filter((edge) => edge.target === sourceId)
-      return sourceIncomingEdges.length === 0
-    }
-
-    // Non-trigger blocks need a snapshot to exist (so upstream outputs are available)
-    const dependenciesSatisfied =
-      isTriggerBlock || (snapshot && incomingEdges.every((edge) => isSourceSatisfied(edge.source)))
-    const isNoteBlock = block.type === 'note'
-    const isInsideSubflow =
-      block.parentId && (block.parentType === 'loop' || block.parentType === 'parallel')
-
-    if (isInsideSubflow) return { canRun: false, reason: 'Cannot run from inside subflow' }
-    if (!dependenciesSatisfied) return { canRun: false, reason: 'Run upstream blocks first' }
-    if (isNoteBlock) return { canRun: false, reason: undefined }
-    if (isExecuting) return { canRun: false, reason: undefined }
-
-    return { canRun: true, reason: undefined }
-  }, [contextMenuBlocks, edges, workflowIdParam, getLastExecutionSnapshot, isExecuting])
-
   const handleContextAddBlock = useCallback(() => {
     useSearchModalStore.getState().open()
   }, [])
@@ -1800,32 +1750,37 @@ const WorkflowContent = React.memo(() => {
       )
   }, [screenToFlowPosition, handleToolbarDrop])
 
-  /** Tracks blocks to pan to after diff updates. */
+  /**
+   * Focus canvas on changed blocks when diff appears.
+   */
   const pendingZoomBlockIdsRef = useRef<Set<string> | null>(null)
-  const seenDiffBlocksRef = useRef<Set<string>>(new Set())
+  const prevDiffReadyRef = useRef(false)
 
-  /** Queues newly changed blocks for viewport panning. */
+  // Phase 1: When diff becomes ready, record which blocks we want to zoom to
+  // Phase 2 effect is located after displayNodes is defined (search for "Phase 2")
   useEffect(() => {
-    if (!isDiffReady || !diffAnalysis) {
-      pendingZoomBlockIdsRef.current = null
-      seenDiffBlocksRef.current.clear()
-      return
-    }
+    if (isDiffReady && !prevDiffReadyRef.current && diffAnalysis) {
+      // Diff just became ready - record blocks to zoom to
+      const changedBlockIds = [
+        ...(diffAnalysis.new_blocks || []),
+        ...(diffAnalysis.edited_blocks || []),
+      ]
 
-    const newBlocks = new Set<string>()
-    const allBlocks = [...(diffAnalysis.new_blocks || []), ...(diffAnalysis.edited_blocks || [])]
-
-    for (const id of allBlocks) {
-      if (!seenDiffBlocksRef.current.has(id)) {
-        newBlocks.add(id)
+      if (changedBlockIds.length > 0) {
+        pendingZoomBlockIdsRef.current = new Set(changedBlockIds)
+      } else {
+        // No specific blocks to focus on, fit all after a frame
+        pendingZoomBlockIdsRef.current = null
+        requestAnimationFrame(() => {
+          fitViewToBounds({ padding: 0.1, duration: 600 })
+        })
       }
-      seenDiffBlocksRef.current.add(id)
+    } else if (!isDiffReady && prevDiffReadyRef.current) {
+      // Diff was cleared (accepted/rejected) - cancel any pending zoom
+      pendingZoomBlockIdsRef.current = null
     }
-
-    if (newBlocks.size > 0) {
-      pendingZoomBlockIdsRef.current = newBlocks
-    }
-  }, [isDiffReady, diffAnalysis])
+    prevDiffReadyRef.current = isDiffReady
+  }, [isDiffReady, diffAnalysis, fitViewToBounds])
 
   /** Displays trigger warning notifications. */
   useEffect(() => {
@@ -2233,12 +2188,18 @@ const WorkflowContent = React.memo(() => {
     })
   }, [derivedNodes, blocks, pendingSelection, clearPendingSelection])
 
-  /** Pans viewport to pending blocks once they have valid dimensions. */
+  // Phase 2: When displayNodes updates, check if pending zoom blocks are ready
+  // (Phase 1 is located earlier in the file where pendingZoomBlockIdsRef is defined)
   useEffect(() => {
     const pendingBlockIds = pendingZoomBlockIdsRef.current
-    if (!pendingBlockIds || pendingBlockIds.size === 0) return
+    if (!pendingBlockIds || pendingBlockIds.size === 0) {
+      return
+    }
 
+    // Find the nodes we're waiting for
     const pendingNodes = displayNodes.filter((node) => pendingBlockIds.has(node.id))
+
+    // Check if all expected nodes are present with valid dimensions
     const allNodesReady =
       pendingNodes.length === pendingBlockIds.size &&
       pendingNodes.every(
@@ -2250,20 +2211,16 @@ const WorkflowContent = React.memo(() => {
       )
 
     if (allNodesReady) {
-      logger.info('Focusing on changed blocks', {
+      logger.info('Diff ready - focusing on changed blocks', {
         changedBlockIds: Array.from(pendingBlockIds),
         foundNodes: pendingNodes.length,
       })
+      // Clear pending state before zooming to prevent re-triggers
       pendingZoomBlockIdsRef.current = null
-
-      const nodesWithAbsolutePositions = pendingNodes.map((node) => ({
-        ...node,
-        position: getNodeAbsolutePosition(node.id),
-      }))
-
+      // Use requestAnimationFrame to ensure React has finished rendering
       requestAnimationFrame(() => {
         fitViewToBounds({
-          nodes: nodesWithAbsolutePositions,
+          nodes: pendingNodes,
           duration: 600,
           padding: 0.1,
           minZoom: 0.5,
@@ -2271,7 +2228,7 @@ const WorkflowContent = React.memo(() => {
         })
       })
     }
-  }, [displayNodes, fitViewToBounds, getNodeAbsolutePosition])
+  }, [displayNodes, fitViewToBounds])
 
   /** Handles ActionBar remove-from-subflow events. */
   useEffect(() => {
@@ -2345,12 +2302,33 @@ const WorkflowContent = React.memo(() => {
       window.removeEventListener('remove-from-subflow', handleRemoveFromSubflow as EventListener)
   }, [blocks, edgesForDisplay, getNodeAbsolutePosition, collaborativeBatchUpdateParent])
 
+  /** Handles node changes - applies changes and resolves parent-child selection conflicts. */
+  const onNodesChange = useCallback(
+    (changes: NodeChange[]) => {
+      selectedIdsRef.current = null
+      setDisplayNodes((nds) => {
+        const updated = applyNodeChanges(changes, nds)
+        const hasSelectionChange = changes.some((c) => c.type === 'select')
+        if (!hasSelectionChange) return updated
+        const resolved = resolveParentChildSelectionConflicts(updated, blocks)
+        selectedIdsRef.current = resolved.filter((node) => node.selected).map((node) => node.id)
+        return resolved
+      })
+      const selectedIds = selectedIdsRef.current as string[] | null
+      if (selectedIds !== null) {
+        syncPanelWithSelection(selectedIds)
+      }
+    },
+    [blocks]
+  )
+
   /**
-   * Updates container dimensions in displayNodes during drag or keyboard movement.
+   * Updates container dimensions in displayNodes during drag.
+   * This allows live resizing of containers as their children are dragged.
    */
-  const updateContainerDimensionsDuringMove = useCallback(
-    (movedNodeId: string, movedNodePosition: { x: number; y: number }) => {
-      const parentId = blocks[movedNodeId]?.data?.parentId
+  const updateContainerDimensionsDuringDrag = useCallback(
+    (draggedNodeId: string, draggedNodePosition: { x: number; y: number }) => {
+      const parentId = blocks[draggedNodeId]?.data?.parentId
       if (!parentId) return
 
       setDisplayNodes((currentNodes) => {
@@ -2358,7 +2336,7 @@ const WorkflowContent = React.memo(() => {
         if (childNodes.length === 0) return currentNodes
 
         const childPositions = childNodes.map((node) => {
-          const nodePosition = node.id === movedNodeId ? movedNodePosition : node.position
+          const nodePosition = node.id === draggedNodeId ? draggedNodePosition : node.position
           const { width, height } = getBlockDimensions(node.id)
           return { x: nodePosition.x, y: nodePosition.y, width, height }
         })
@@ -2389,55 +2367,6 @@ const WorkflowContent = React.memo(() => {
     [blocks, getBlockDimensions]
   )
 
-  /** Handles node changes - applies changes and resolves parent-child selection conflicts. */
-  const onNodesChange = useCallback(
-    (changes: NodeChange[]) => {
-      selectedIdsRef.current = null
-      setDisplayNodes((nds) => {
-        const updated = applyNodeChanges(changes, nds)
-        const hasSelectionChange = changes.some((c) => c.type === 'select')
-        if (!hasSelectionChange) return updated
-        const resolved = resolveParentChildSelectionConflicts(updated, blocks)
-        selectedIdsRef.current = resolved.filter((node) => node.selected).map((node) => node.id)
-        return resolved
-      })
-      const selectedIds = selectedIdsRef.current as string[] | null
-      if (selectedIds !== null) {
-        syncPanelWithSelection(selectedIds)
-      }
-
-      // Handle position changes (e.g., from keyboard arrow key movement)
-      // Update container dimensions when child nodes are moved and persist to backend
-      // Only persist if not in a drag operation (drag-end is handled by onNodeDragStop)
-      const isInDragOperation =
-        getDragStartPosition() !== null || multiNodeDragStartRef.current.size > 0
-      const keyboardPositionUpdates: Array<{ id: string; position: { x: number; y: number } }> = []
-      for (const change of changes) {
-        if (
-          change.type === 'position' &&
-          !change.dragging &&
-          'position' in change &&
-          change.position
-        ) {
-          updateContainerDimensionsDuringMove(change.id, change.position)
-          if (!isInDragOperation) {
-            keyboardPositionUpdates.push({ id: change.id, position: change.position })
-          }
-        }
-      }
-      // Persist keyboard movements to backend for collaboration sync
-      if (keyboardPositionUpdates.length > 0) {
-        collaborativeBatchUpdatePositions(keyboardPositionUpdates)
-      }
-    },
-    [
-      blocks,
-      updateContainerDimensionsDuringMove,
-      collaborativeBatchUpdatePositions,
-      getDragStartPosition,
-    ]
-  )
-
   /**
    * Effect to resize loops when nodes change (add/remove/position change).
    * Runs on structural changes only - not during drag (position-only changes).
@@ -2682,7 +2611,7 @@ const WorkflowContent = React.memo(() => {
 
       // If the node is inside a container, update container dimensions during drag
       if (currentParentId) {
-        updateContainerDimensionsDuringMove(node.id, node.position)
+        updateContainerDimensionsDuringDrag(node.id, node.position)
       }
 
       // Check if this is a starter block - starter blocks should never be in containers
@@ -2799,7 +2728,7 @@ const WorkflowContent = React.memo(() => {
       blocks,
       getNodeAbsolutePosition,
       getNodeDepth,
-      updateContainerDimensionsDuringMove,
+      updateContainerDimensionsDuringDrag,
       highlightContainerNode,
     ]
   )
@@ -3489,19 +3418,11 @@ const WorkflowContent = React.memo(() => {
               onRemoveFromSubflow={handleContextRemoveFromSubflow}
               onOpenEditor={handleContextOpenEditor}
               onRename={handleContextRename}
-              onRunFromBlock={handleContextRunFromBlock}
-              onRunUntilBlock={handleContextRunUntilBlock}
               hasClipboard={hasClipboard()}
               showRemoveFromSubflow={contextMenuBlocks.some(
                 (b) => b.parentId && (b.parentType === 'loop' || b.parentType === 'parallel')
               )}
-              canRunFromBlock={runFromBlockState.canRun}
               disableEdit={!effectivePermissions.canEdit}
-              isExecuting={isExecuting}
-              isPositionalTrigger={
-                contextMenuBlocks.length === 1 &&
-                edges.filter((e) => e.target === contextMenuBlocks[0]?.id).length === 0
-              }
             />
 
             <CanvasMenu

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

@@ -1141,17 +1141,15 @@ function PreviewEditorContent({
     <div className='relative flex h-full w-80 flex-col overflow-hidden border-[var(--border)] border-l bg-[var(--surface-1)]'>
       {/* Header - styled like editor */}
       <div className='mx-[-1px] flex flex-shrink-0 items-center gap-[8px] rounded-b-[4px] border-[var(--border)] border-x border-b bg-[var(--surface-4)] px-[12px] py-[6px]'>
-        {block.type !== 'note' && (
-          <div
-            className='flex h-[18px] w-[18px] flex-shrink-0 items-center justify-center rounded-[4px]'
-            style={{ backgroundColor: blockConfig.bgColor }}
-          >
-            <IconComponent
-              icon={blockConfig.icon}
-              className='h-[12px] w-[12px] text-[var(--white)]'
-            />
-          </div>
-        )}
+        <div
+          className='flex h-[18px] w-[18px] flex-shrink-0 items-center justify-center rounded-[4px]'
+          style={{ backgroundColor: blockConfig.bgColor }}
+        >
+          <IconComponent
+            icon={blockConfig.icon}
+            className='h-[12px] w-[12px] text-[var(--white)]'
+          />
+        </div>
         <span className='min-w-0 flex-1 truncate font-medium text-[14px] text-[var(--text-primary)]'>
           {block.name || blockConfig.name}
         </span>

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

@@ -411,9 +411,8 @@ function WorkflowPreviewBlockInner({ data }: NodeProps<WorkflowPreviewBlockData>
 
   const IconComponent = blockConfig.icon
   const isStarterOrTrigger = blockConfig.category === 'triggers' || type === 'starter' || isTrigger
-  const isNoteBlock = type === 'note'
 
-  const shouldShowDefaultHandles = !isStarterOrTrigger && !isNoteBlock
+  const shouldShowDefaultHandles = !isStarterOrTrigger
   const hasSubBlocks = visibleSubBlocks.length > 0
   const hasContentBelowHeader =
     type === 'condition'
@@ -575,8 +574,8 @@ function WorkflowPreviewBlockInner({ data }: NodeProps<WorkflowPreviewBlockData>
         </>
       )}
 
-      {/* Source and error handles for non-condition/router/note blocks */}
-      {type !== 'condition' && type !== 'router_v2' && type !== 'response' && !isNoteBlock && (
+      {/* Source and error handles for non-condition/router blocks */}
+      {type !== 'condition' && type !== 'router_v2' && type !== 'response' && (
         <>
           <Handle
             type='source'

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

@@ -3,8 +3,6 @@
 import { memo } from 'react'
 import { RepeatIcon, SplitIcon } from 'lucide-react'
 import { Handle, type NodeProps, Position } from 'reactflow'
-import { Badge } from '@/components/emcn'
-import { cn } from '@/lib/core/utils/cn'
 import { HANDLE_POSITIONS } from '@/lib/workflows/blocks/block-dimensions'
 
 /** Execution status for subflows in preview mode */
@@ -15,8 +13,6 @@ interface WorkflowPreviewSubflowData {
   width?: number
   height?: number
   kind: 'loop' | 'parallel'
-  /** Whether this subflow is enabled */
-  enabled?: boolean
   /** Whether this subflow is selected in preview mode */
   isPreviewSelected?: boolean
   /** Execution status for highlighting the subflow container */
@@ -31,15 +27,7 @@ interface WorkflowPreviewSubflowData {
  * or interactive features.
  */
 function WorkflowPreviewSubflowInner({ data }: NodeProps<WorkflowPreviewSubflowData>) {
-  const {
-    name,
-    width = 500,
-    height = 300,
-    kind,
-    enabled = true,
-    isPreviewSelected = false,
-    executionStatus,
-  } = data
+  const { name, width = 500, height = 300, kind, isPreviewSelected = false, executionStatus } = data
 
   const isLoop = kind === 'loop'
   const BlockIcon = isLoop ? RepeatIcon : SplitIcon
@@ -96,21 +84,14 @@ function WorkflowPreviewSubflowInner({ data }: NodeProps<WorkflowPreviewSubflowD
         <div className='flex min-w-0 flex-1 items-center gap-[10px]'>
           <div
             className='flex h-[24px] w-[24px] flex-shrink-0 items-center justify-center rounded-[6px]'
-            style={{ backgroundColor: enabled ? blockIconBg : 'var(--surface-4)' }}
+            style={{ backgroundColor: blockIconBg }}
           >
             <BlockIcon className='h-[16px] w-[16px] text-white' />
           </div>
-          <span
-            className={cn(
-              'truncate font-medium text-[16px]',
-              !enabled && 'text-[var(--text-muted)]'
-            )}
-            title={blockName}
-          >
+          <span className='font-medium text-[16px]' title={blockName}>
             {blockName}
           </span>
         </div>
-        {!enabled && <Badge variant='gray-secondary'>disabled</Badge>}
       </div>
 
       {/* Content area - matches workflow structure */}

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

@@ -23,7 +23,11 @@ import type { BlockState, WorkflowState } from '@/stores/workflows/workflow/type
 
 const logger = createLogger('PreviewWorkflow')
 
-/** Gets block dimensions, using stored values or defaults. */
+/**
+ * Gets block dimensions for preview purposes.
+ * For containers, uses stored dimensions or defaults.
+ * For regular blocks, uses stored height or estimates based on type.
+ */
 function getPreviewBlockDimensions(block: BlockState): { width: number; height: number } {
   if (block.type === 'loop' || block.type === 'parallel') {
     return {
@@ -46,7 +50,10 @@ function getPreviewBlockDimensions(block: BlockState): { width: number; height:
   return estimateBlockDimensions(block.type)
 }
 
-/** Calculates container dimensions from child block positions. */
+/**
+ * Calculates container dimensions based on child block positions and sizes.
+ * Mirrors the logic from useNodeUtilities.calculateLoopDimensions.
+ */
 function calculateContainerDimensions(
   containerId: string,
   blocks: Record<string, BlockState>
@@ -84,7 +91,12 @@ function calculateContainerDimensions(
   return { width, height }
 }
 
-/** Finds the leftmost block ID, excluding subflow containers. */
+/**
+ * Finds the leftmost block ID from a workflow state.
+ * Excludes subflow containers (loop/parallel) from consideration.
+ * @param workflowState - The workflow state to search
+ * @returns The ID of the leftmost block, or null if no blocks exist
+ */
 export function getLeftmostBlockId(workflowState: WorkflowState | null | undefined): string | null {
   if (!workflowState?.blocks) return null
 
@@ -106,7 +118,7 @@ export function getLeftmostBlockId(workflowState: WorkflowState | null | undefin
 /** Execution status for edges/nodes in the preview */
 type ExecutionStatus = 'success' | 'error' | 'not-executed'
 
-/** Calculates absolute position, handling nested subflows. */
+/** Calculates absolute position for blocks, handling nested subflows */
 function calculateAbsolutePosition(
   block: BlockState,
   blocks: Record<string, BlockState>
@@ -152,7 +164,10 @@ interface PreviewWorkflowProps {
   lightweight?: boolean
 }
 
-/** Preview node types using minimal, hook-free components. */
+/**
+ * Preview node types using minimal components without hooks or store subscriptions.
+ * This prevents interaction issues while allowing canvas panning and node clicking.
+ */
 const previewNodeTypes: NodeTypes = {
   workflowBlock: PreviewBlock,
   noteBlock: PreviewBlock,
@@ -170,7 +185,11 @@ interface FitViewOnChangeProps {
   containerRef: React.RefObject<HTMLDivElement | null>
 }
 
-/** Calls fitView on node changes or container resize. */
+/**
+ * Helper component that calls fitView when the set of nodes changes or when the container resizes.
+ * Only triggers on actual node additions/removals, not on selection changes.
+ * Must be rendered inside ReactFlowProvider.
+ */
 function FitViewOnChange({ nodeIds, fitPadding, containerRef }: FitViewOnChangeProps) {
   const { fitView } = useReactFlow()
   const lastNodeIdsRef = useRef<string | null>(null)
@@ -210,7 +229,16 @@ function FitViewOnChange({ nodeIds, fitPadding, containerRef }: FitViewOnChangeP
   return null
 }
 
-/** Readonly workflow visualization with execution status highlighting. */
+/**
+ * Readonly workflow component for visualizing workflow state.
+ * Renders blocks, subflows, and edges with execution status highlighting.
+ *
+ * @remarks
+ * - Supports panning and node click interactions
+ * - Shows execution path via green edges for successful paths
+ * - Error edges display red by default, green when error path was taken
+ * - Fits view automatically when nodes change or container resizes
+ */
 export function PreviewWorkflow({
   workflowState,
   className,
@@ -272,58 +300,49 @@ export function PreviewWorkflow({
     return map
   }, [workflowState.blocks, isValidWorkflowState])
 
-  /** Maps base block IDs to execution data, handling parallel iteration variants (blockId₍n₎). */
-  const blockExecutionMap = useMemo(() => {
-    if (!executedBlocks) return new Map<string, { status: string }>()
-
-    const map = new Map<string, { status: string }>()
-    for (const [key, value] of Object.entries(executedBlocks)) {
-      // Extract base ID (remove iteration suffix like ₍0₎)
-      const baseId = key.includes('₍') ? key.split('₍')[0] : key
-      // Keep first match or error status (error takes precedence)
-      const existing = map.get(baseId)
-      if (!existing || value.status === 'error') {
-        map.set(baseId, value)
-      }
-    }
-    return map
-  }, [executedBlocks])
-
-  /** Derives subflow status from children. Error takes precedence. */
+  /** Derives subflow execution status from child blocks */
   const getSubflowExecutionStatus = useMemo(() => {
     return (subflowId: string): ExecutionStatus | undefined => {
+      if (!executedBlocks) return undefined
+
       const childIds = subflowChildrenMap.get(subflowId)
       if (!childIds?.length) return undefined
 
-      const executedChildren = childIds
-        .map((id) => blockExecutionMap.get(id))
-        .filter((status): status is { status: string } => Boolean(status))
+      const childStatuses = childIds.map((id) => executedBlocks[id]).filter(Boolean)
+      if (childStatuses.length === 0) return undefined
 
-      if (executedChildren.length === 0) return undefined
-      if (executedChildren.some((s) => s.status === 'error')) return 'error'
-      return 'success'
+      if (childStatuses.some((s) => s.status === 'error')) return 'error'
+      if (childStatuses.some((s) => s.status === 'success')) return 'success'
+      return 'not-executed'
     }
-  }, [subflowChildrenMap, blockExecutionMap])
+  }, [executedBlocks, subflowChildrenMap])
 
-  /** Gets block status. Subflows derive status from children. */
+  /** Gets execution status for any block, deriving subflow status from children */
   const getBlockExecutionStatus = useMemo(() => {
     return (blockId: string): { status: string; executed: boolean } | undefined => {
-      const directStatus = blockExecutionMap.get(blockId)
+      if (!executedBlocks) return undefined
+
+      const directStatus = executedBlocks[blockId]
       if (directStatus) {
         return { status: directStatus.status, executed: true }
       }
 
       const block = workflowState.blocks?.[blockId]
-      if (block?.type === 'loop' || block?.type === 'parallel') {
+      if (block && (block.type === 'loop' || block.type === 'parallel')) {
         const subflowStatus = getSubflowExecutionStatus(blockId)
         if (subflowStatus) {
           return { status: subflowStatus, executed: true }
         }
+
+        const incomingEdge = workflowState.edges?.find((e) => e.target === blockId)
+        if (incomingEdge && executedBlocks[incomingEdge.source]?.status === 'success') {
+          return { status: 'not-executed', executed: true }
+        }
       }
 
       return undefined
     }
-  }, [workflowState.blocks, getSubflowExecutionStatus, blockExecutionMap])
+  }, [executedBlocks, workflowState.blocks, workflowState.edges, getSubflowExecutionStatus])
 
   const edgesStructure = useMemo(() => {
     if (!isValidWorkflowState) return { count: 0, ids: '' }
@@ -361,7 +380,6 @@ export function PreviewWorkflow({
             width: dimensions.width,
             height: dimensions.height,
             kind: block.type as 'loop' | 'parallel',
-            enabled: block.enabled ?? true,
             isPreviewSelected: isSelected,
             executionStatus: subflowExecutionStatus,
             lightweight,
@@ -388,11 +406,9 @@ export function PreviewWorkflow({
         }
       }
 
-      const nodeType = block.type === 'note' ? 'noteBlock' : 'workflowBlock'
-
       nodeArray.push({
         id: blockId,
-        type: nodeType,
+        type: 'workflowBlock',
         position: absolutePosition,
         draggable: false,
         zIndex: block.data?.parentId ? 10 : undefined,
@@ -426,29 +442,48 @@ export function PreviewWorkflow({
   const edges: Edge[] = useMemo(() => {
     if (!isValidWorkflowState) return []
 
-    /** Edge is green if target executed and source condition met by edge type. */
+    /**
+     * Determines edge execution status for visualization.
+     * Error edges turn green when taken (source errored, target executed).
+     * Normal edges turn green when both source succeeded and target executed.
+     */
     const getEdgeExecutionStatus = (edge: {
       source: string
       target: string
       sourceHandle?: string | null
     }): ExecutionStatus | undefined => {
-      if (blockExecutionMap.size === 0) return undefined
-
-      const targetStatus = getBlockExecutionStatus(edge.target)
-      if (!targetStatus?.executed) return 'not-executed'
+      if (!executedBlocks) return undefined
 
       const sourceStatus = getBlockExecutionStatus(edge.source)
-      const { sourceHandle } = edge
+      const targetStatus = getBlockExecutionStatus(edge.target)
+      const isErrorEdge = edge.sourceHandle === 'error'
 
-      if (sourceHandle === 'error') {
-        return sourceStatus?.status === 'error' ? 'success' : 'not-executed'
+      if (isErrorEdge) {
+        return sourceStatus?.status === 'error' && targetStatus?.executed
+          ? 'success'
+          : 'not-executed'
       }
 
-      if (sourceHandle === 'loop-start-source' || sourceHandle === 'parallel-start-source') {
+      const isSubflowStartEdge =
+        edge.sourceHandle === 'loop-start-source' || edge.sourceHandle === 'parallel-start-source'
+
+      if (isSubflowStartEdge) {
+        const incomingEdge = workflowState.edges?.find((e) => e.target === edge.source)
+        const incomingSucceeded = incomingEdge
+          ? executedBlocks[incomingEdge.source]?.status === 'success'
+          : false
+        return incomingSucceeded ? 'success' : 'not-executed'
+      }
+
+      const targetBlock = workflowState.blocks?.[edge.target]
+      const targetIsSubflow =
+        targetBlock && (targetBlock.type === 'loop' || targetBlock.type === 'parallel')
+
+      if (sourceStatus?.status === 'success' && (targetStatus?.executed || targetIsSubflow)) {
         return 'success'
       }
 
-      return sourceStatus?.status === 'success' ? 'success' : 'not-executed'
+      return 'not-executed'
     }
 
     return (workflowState.edges || []).map((edge) => {
@@ -470,8 +505,9 @@ export function PreviewWorkflow({
   }, [
     edgesStructure,
     workflowState.edges,
+    workflowState.blocks,
     isValidWorkflowState,
-    blockExecutionMap,
+    executedBlocks,
     getBlockExecutionStatus,
   ])
 

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

@@ -39,8 +39,8 @@ interface WorkflowStackEntry {
 
 /**
  * Extracts child trace spans from a workflow block's execution data.
- * Checks `children` property (where trace-spans processing puts them),
- * with fallback to `output.childTraceSpans` for old stored logs.
+ * Checks both the `children` property (where trace span processing moves them)
+ * and the legacy `output.childTraceSpans` for compatibility.
  */
 function extractChildTraceSpans(blockExecution: BlockExecutionData | undefined): TraceSpan[] {
   if (!blockExecution) return []
@@ -49,7 +49,6 @@ function extractChildTraceSpans(blockExecution: BlockExecutionData | undefined):
     return blockExecution.children
   }
 
-  // Backward compat: old stored logs may have childTraceSpans in output
   if (blockExecution.output && typeof blockExecution.output === 'object') {
     const output = blockExecution.output as Record<string, unknown>
     if (Array.isArray(output.childTraceSpans)) {

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

@@ -2,38 +2,19 @@
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Command } from 'cmdk'
-import { Database, HelpCircle, Layout, Settings } from 'lucide-react'
+import { BookOpen, Layout, ScrollText } from 'lucide-react'
 import { useParams, useRouter } from 'next/navigation'
 import { createPortal } from 'react-dom'
-import { Library } from '@/components/emcn'
+import { useBrandConfig } from '@/lib/branding/branding'
 import { cn } from '@/lib/core/utils/cn'
 import { hasTriggerCapability } from '@/lib/workflows/triggers/trigger-utils'
 import { SIDEBAR_SCROLL_EVENT } from '@/app/workspace/[workspaceId]/w/components/sidebar/sidebar'
-import { usePermissionConfig } from '@/hooks/use-permission-config'
 import { useSearchModalStore } from '@/stores/modals/search/store'
 import type {
   SearchBlockItem,
   SearchDocItem,
   SearchToolOperationItem,
 } from '@/stores/modals/search/types'
-import { useSettingsModalStore } from '@/stores/modals/settings/store'
-
-function customFilter(value: string, search: string): number {
-  const searchLower = search.toLowerCase()
-  const valueLower = value.toLowerCase()
-
-  if (valueLower === searchLower) return 1
-  if (valueLower.startsWith(searchLower)) return 0.9
-  if (valueLower.includes(searchLower)) return 0.7
-
-  const searchWords = searchLower.split(/\s+/).filter(Boolean)
-  if (searchWords.length > 1) {
-    const allWordsMatch = searchWords.every((word) => valueLower.includes(word))
-    if (allWordsMatch) return 0.5
-  }
-
-  return 0
-}
 
 interface SearchModalProps {
   open: boolean
@@ -62,10 +43,8 @@ interface PageItem {
   id: string
   name: string
   icon: React.ComponentType<{ className?: string }>
-  href?: string
-  onClick?: () => void
+  href: string
   shortcut?: string
-  hidden?: boolean
 }
 
 export function SearchModal({
@@ -78,10 +57,10 @@ export function SearchModal({
   const params = useParams()
   const router = useRouter()
   const workspaceId = params.workspaceId as string
+  const brand = useBrandConfig()
   const inputRef = useRef<HTMLInputElement>(null)
+  const [search, setSearch] = useState('')
   const [mounted, setMounted] = useState(false)
-  const openSettingsModal = useSettingsModalStore((state) => state.openModal)
-  const { config: permissionConfig } = usePermissionConfig()
 
   useEffect(() => {
     setMounted(true)
@@ -91,71 +70,42 @@ export function SearchModal({
     (state) => state.data
   )
 
-  const openHelpModal = useCallback(() => {
-    window.dispatchEvent(new CustomEvent('open-help-modal'))
-  }, [])
-
   const pages = useMemo(
-    (): PageItem[] =>
-      [
-        {
-          id: 'logs',
-          name: 'Logs',
-          icon: Library,
-          href: `/workspace/${workspaceId}/logs`,
-          shortcut: '⌘⇧L',
-        },
-        {
-          id: 'templates',
-          name: 'Templates',
-          icon: Layout,
-          href: `/workspace/${workspaceId}/templates`,
-          hidden: permissionConfig.hideTemplates,
-        },
-        {
-          id: 'knowledge-base',
-          name: 'Knowledge Base',
-          icon: Database,
-          href: `/workspace/${workspaceId}/knowledge`,
-          hidden: permissionConfig.hideKnowledgeBaseTab,
-        },
-        {
-          id: 'help',
-          name: 'Help',
-          icon: HelpCircle,
-          onClick: openHelpModal,
-        },
-        {
-          id: 'settings',
-          name: 'Settings',
-          icon: Settings,
-          onClick: openSettingsModal,
-        },
-      ].filter((page) => !page.hidden),
-    [
-      workspaceId,
-      openHelpModal,
-      openSettingsModal,
-      permissionConfig.hideTemplates,
-      permissionConfig.hideKnowledgeBaseTab,
-    ]
+    (): PageItem[] => [
+      {
+        id: 'logs',
+        name: 'Logs',
+        icon: ScrollText,
+        href: `/workspace/${workspaceId}/logs`,
+        shortcut: '⌘⇧L',
+      },
+      {
+        id: 'templates',
+        name: 'Templates',
+        icon: Layout,
+        href: `/workspace/${workspaceId}/templates`,
+      },
+      {
+        id: 'docs',
+        name: 'Docs',
+        icon: BookOpen,
+        href: brand.documentationUrl || 'https://docs.sim.ai/',
+      },
+    ],
+    [workspaceId, brand.documentationUrl]
   )
 
   useEffect(() => {
-    if (open && inputRef.current) {
-      const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
-        window.HTMLInputElement.prototype,
-        'value'
-      )?.set
-      if (nativeInputValueSetter) {
-        nativeInputValueSetter.call(inputRef.current, '')
-        inputRef.current.dispatchEvent(new Event('input', { bubbles: true }))
-      }
-      inputRef.current.focus()
+    if (open) {
+      setSearch('')
+      requestAnimationFrame(() => {
+        inputRef.current?.focus()
+      })
     }
   }, [open])
 
-  const handleSearchChange = useCallback(() => {
+  const handleSearchChange = useCallback((value: string) => {
+    setSearch(value)
     requestAnimationFrame(() => {
       const list = document.querySelector('[cmdk-list]')
       if (list) {
@@ -229,14 +179,10 @@ export function SearchModal({
 
   const handlePageSelect = useCallback(
     (page: PageItem) => {
-      if (page.onClick) {
-        page.onClick()
-      } else if (page.href) {
-        if (page.href.startsWith('http')) {
-          window.open(page.href, '_blank', 'noopener,noreferrer')
-        } else {
-          router.push(page.href)
-        }
+      if (page.href.startsWith('http')) {
+        window.open(page.href, '_blank', 'noopener,noreferrer')
+      } else {
+        router.push(page.href)
       }
       onOpenChange(false)
     },
@@ -257,6 +203,28 @@ export function SearchModal({
   const showToolOperations = isOnWorkflowPage && toolOperations.length > 0
   const showDocs = isOnWorkflowPage && docs.length > 0
 
+  const customFilter = useCallback((value: string, search: string, keywords?: string[]) => {
+    const searchLower = search.toLowerCase()
+    const valueLower = value.toLowerCase()
+
+    if (valueLower === searchLower) return 1
+    if (valueLower.startsWith(searchLower)) return 0.8
+    if (valueLower.includes(searchLower)) return 0.6
+
+    const searchWords = searchLower.split(/\s+/).filter(Boolean)
+    const allWordsMatch = searchWords.every((word) => valueLower.includes(word))
+    if (allWordsMatch && searchWords.length > 0) return 0.4
+
+    if (keywords?.length) {
+      const keywordsLower = keywords.join(' ').toLowerCase()
+      if (keywordsLower.includes(searchLower)) return 0.3
+      const keywordWordsMatch = searchWords.every((word) => keywordsLower.includes(word))
+      if (keywordWordsMatch && searchWords.length > 0) return 0.2
+    }
+
+    return 0
+  }, [])
+
   if (!mounted) return null
 
   return createPortal(
@@ -285,6 +253,7 @@ export function SearchModal({
         <Command label='Search' filter={customFilter}>
           <Command.Input
             ref={inputRef}
+            value={search}
             autoFocus
             onValueChange={handleSearchChange}
             placeholder='Search anything...'
@@ -300,7 +269,8 @@ export function SearchModal({
                 {blocks.map((block) => (
                   <CommandItem
                     key={block.id}
-                    value={`${block.name} block-${block.id}`}
+                    value={block.name}
+                    keywords={[block.description]}
                     onSelect={() => handleBlockSelect(block, 'block')}
                     icon={block.icon}
                     bgColor={block.bgColor}
@@ -317,7 +287,8 @@ export function SearchModal({
                 {tools.map((tool) => (
                   <CommandItem
                     key={tool.id}
-                    value={`${tool.name} tool-${tool.id}`}
+                    value={tool.name}
+                    keywords={[tool.description]}
                     onSelect={() => handleBlockSelect(tool, 'tool')}
                     icon={tool.icon}
                     bgColor={tool.bgColor}
@@ -334,7 +305,8 @@ export function SearchModal({
                 {triggers.map((trigger) => (
                   <CommandItem
                     key={trigger.id}
-                    value={`${trigger.name} trigger-${trigger.id}`}
+                    value={trigger.name}
+                    keywords={[trigger.description]}
                     onSelect={() => handleBlockSelect(trigger, 'trigger')}
                     icon={trigger.icon}
                     bgColor={trigger.bgColor}
@@ -351,7 +323,7 @@ export function SearchModal({
                 {workflows.map((workflow) => (
                   <Command.Item
                     key={workflow.id}
-                    value={`${workflow.name} workflow-${workflow.id}`}
+                    value={workflow.name}
                     onSelect={() => handleWorkflowSelect(workflow)}
                     className='group flex h-[28px] w-full cursor-pointer items-center gap-[8px] rounded-[6px] px-[10px] text-left text-[15px] aria-selected:bg-[var(--border)] aria-selected:shadow-sm data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50'
                   >
@@ -373,7 +345,8 @@ export function SearchModal({
                 {toolOperations.map((op) => (
                   <CommandItem
                     key={op.id}
-                    value={`${op.searchValue} operation-${op.id}`}
+                    value={op.searchValue}
+                    keywords={op.keywords}
                     onSelect={() => handleToolOperationSelect(op)}
                     icon={op.icon}
                     bgColor={op.bgColor}
@@ -390,7 +363,7 @@ export function SearchModal({
                 {workspaces.map((workspace) => (
                   <Command.Item
                     key={workspace.id}
-                    value={`${workspace.name} workspace-${workspace.id}`}
+                    value={workspace.name}
                     onSelect={() => handleWorkspaceSelect(workspace)}
                     className='group flex h-[28px] w-full cursor-pointer items-center gap-[8px] rounded-[6px] px-[10px] text-left text-[15px] aria-selected:bg-[var(--border)] aria-selected:shadow-sm data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50'
                   >
@@ -408,7 +381,7 @@ export function SearchModal({
                 {docs.map((doc) => (
                   <CommandItem
                     key={doc.id}
-                    value={`${doc.name} docs documentation doc-${doc.id}`}
+                    value={`${doc.name} docs documentation`}
                     onSelect={() => handleDocSelect(doc)}
                     icon={doc.icon}
                     bgColor='#6B7280'
@@ -427,7 +400,7 @@ export function SearchModal({
                   return (
                     <Command.Item
                       key={page.id}
-                      value={`${page.name} page-${page.id}`}
+                      value={page.name}
                       onSelect={() => handlePageSelect(page)}
                       className='group flex h-[28px] w-full cursor-pointer items-center gap-[8px] rounded-[6px] px-[10px] text-left text-[15px] aria-selected:bg-[var(--border)] aria-selected:shadow-sm data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50'
                     >
@@ -460,6 +433,7 @@ const groupHeadingClassName =
 
 interface CommandItemProps {
   value: string
+  keywords?: string[]
   onSelect: () => void
   icon: React.ComponentType<{ className?: string }>
   bgColor: string
@@ -469,6 +443,7 @@ interface CommandItemProps {
 
 function CommandItem({
   value,
+  keywords,
   onSelect,
   icon: Icon,
   bgColor,
@@ -478,6 +453,7 @@ function CommandItem({
   return (
     <Command.Item
       value={value}
+      keywords={keywords}
       onSelect={onSelect}
       className='group flex h-[28px] w-full cursor-pointer items-center gap-[8px] rounded-[6px] px-[10px] text-left text-[15px] aria-selected:bg-[var(--border)] aria-selected:shadow-sm data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50'
     >

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/invite-modal/invite-modal.tsx

@@ -164,7 +164,7 @@ export function InviteModal({ open, onOpenChange, workspaceName }: InviteModalPr
           ...prev,
           {
             email: normalized,
-            permissionType: 'admin',
+            permissionType: 'read',
           },
         ])
       }

apps/sim/blocks/blocks/api.ts

@@ -80,15 +80,6 @@ Example:
         generationType: 'json-object',
       },
     },
-    {
-      id: 'timeout',
-      title: 'Timeout (ms)',
-      type: 'short-input',
-      placeholder: '300000',
-      description:
-        'Request timeout in milliseconds (default: 300000 = 5 minutes, max: 600000 = 10 minutes)',
-      mode: 'advanced',
-    },
   ],
   tools: {
     access: ['http_request'],
@@ -99,7 +90,6 @@ Example:
     headers: { type: 'json', description: 'Request headers' },
     body: { type: 'json', description: 'Request body data' },
     params: { type: 'json', description: 'URL query parameters' },
-    timeout: { type: 'number', description: 'Request timeout in milliseconds' },
   },
   outputs: {
     data: { type: 'json', description: 'API response data (JSON, text, or other formats)' },

apps/sim/blocks/blocks/calcom.ts

@@ -1,668 +0,0 @@
-import { CalComIcon } from '@/components/icons'
-import type { BlockConfig } from '@/blocks/types'
-import { AuthMode } from '@/blocks/types'
-import type { ToolResponse } from '@/tools/types'
-import { getTrigger } from '@/triggers'
-
-export const CalComBlock: BlockConfig<ToolResponse> = {
-  type: 'calcom',
-  name: 'CalCom',
-  description: 'Manage Cal.com bookings, event types, schedules, and availability',
-  authMode: AuthMode.OAuth,
-  triggerAllowed: true,
-  longDescription:
-    'Integrate Cal.com into your workflow. Create and manage bookings, event types, schedules, and check availability slots. Supports creating, listing, rescheduling, and canceling bookings, as well as managing event types and schedules. Can also trigger workflows based on Cal.com webhook events (booking created, cancelled, rescheduled). Connect your Cal.com account via OAuth.',
-  docsLink: 'https://docs.sim.ai/tools/calcom',
-  category: 'tools',
-  bgColor: '#FFFFFE',
-  icon: CalComIcon,
-  subBlocks: [
-    {
-      id: 'operation',
-      title: 'Operation',
-      type: 'dropdown',
-      options: [
-        { label: 'Create Booking', id: 'calcom_create_booking' },
-        { label: 'Get Booking', id: 'calcom_get_booking' },
-        { label: 'List Bookings', id: 'calcom_list_bookings' },
-        { label: 'Cancel Booking', id: 'calcom_cancel_booking' },
-        { label: 'Reschedule Booking', id: 'calcom_reschedule_booking' },
-        { label: 'Confirm Booking', id: 'calcom_confirm_booking' },
-        { label: 'Decline Booking', id: 'calcom_decline_booking' },
-        { label: 'Create Event Type', id: 'calcom_create_event_type' },
-        { label: 'Get Event Type', id: 'calcom_get_event_type' },
-        { label: 'List Event Types', id: 'calcom_list_event_types' },
-        { label: 'Update Event Type', id: 'calcom_update_event_type' },
-        { label: 'Delete Event Type', id: 'calcom_delete_event_type' },
-        { label: 'Create Schedule', id: 'calcom_create_schedule' },
-        { label: 'Get Schedule', id: 'calcom_get_schedule' },
-        { label: 'List Schedules', id: 'calcom_list_schedules' },
-        { label: 'Update Schedule', id: 'calcom_update_schedule' },
-        { label: 'Delete Schedule', id: 'calcom_delete_schedule' },
-        { label: 'Get Default Schedule', id: 'calcom_get_default_schedule' },
-        { label: 'Get Available Slots', id: 'calcom_get_slots' },
-      ],
-      value: () => 'calcom_list_bookings',
-    },
-    {
-      id: 'credential',
-      title: 'Cal.com Account',
-      type: 'oauth-input',
-      serviceId: 'calcom',
-      placeholder: 'Select Cal.com account',
-      required: true,
-    },
-
-    // === Create Booking fields ===
-    {
-      id: 'eventTypeId',
-      title: 'Event Type ID',
-      type: 'short-input',
-      placeholder: 'Enter event type ID (number)',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_booking', 'calcom_get_slots'],
-      },
-      required: { field: 'operation', value: 'calcom_create_booking' },
-    },
-    {
-      id: 'start',
-      title: 'Start Time',
-      type: 'short-input',
-      placeholder: 'ISO 8601 format (e.g., 2024-01-15T10:00:00Z)',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_booking', 'calcom_reschedule_booking', 'calcom_get_slots'],
-      },
-      required: {
-        field: 'operation',
-        value: ['calcom_create_booking', 'calcom_reschedule_booking', 'calcom_get_slots'],
-      },
-      wandConfig: {
-        enabled: true,
-        prompt: `Generate an ISO 8601 timestamp in UTC based on the user's description.
-Format: YYYY-MM-DDTHH:MM:SSZ
-Examples:
-- "tomorrow at 2pm" -> Tomorrow's date at 14:00:00Z
-- "next Monday 9am" -> Next Monday at 09:00:00Z
-- "in 3 hours" -> Current time + 3 hours
-
-Return ONLY the timestamp string - no explanations or quotes.`,
-        placeholder: 'Describe the start time (e.g., "tomorrow at 2pm")...',
-        generationType: 'timestamp',
-      },
-    },
-    {
-      id: 'end',
-      title: 'End Time',
-      type: 'short-input',
-      placeholder: 'ISO 8601 format (e.g., 2024-01-15T11:00:00Z)',
-      condition: { field: 'operation', value: 'calcom_get_slots' },
-      required: { field: 'operation', value: 'calcom_get_slots' },
-      wandConfig: {
-        enabled: true,
-        prompt: `Generate an ISO 8601 timestamp in UTC based on the user's description.
-Format: YYYY-MM-DDTHH:MM:SSZ
-Examples:
-- "end of tomorrow" -> Tomorrow at 23:59:59Z
-- "next Friday" -> Next Friday at 23:59:59Z
-- "in 1 week" -> Current date + 7 days
-
-Return ONLY the timestamp string - no explanations or quotes.`,
-        placeholder: 'Describe the end time (e.g., "end of next week")...',
-        generationType: 'timestamp',
-      },
-    },
-    {
-      id: 'attendeeName',
-      title: 'Attendee Name',
-      type: 'short-input',
-      placeholder: 'Enter attendee name',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-      required: true,
-    },
-    {
-      id: 'attendeeEmail',
-      title: 'Attendee Email',
-      type: 'short-input',
-      placeholder: 'Enter attendee email',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-    },
-    {
-      id: 'attendeeTimeZone',
-      title: 'Attendee Time Zone',
-      type: 'short-input',
-      placeholder: 'e.g., America/New_York, Europe/London',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-      required: true,
-    },
-    {
-      id: 'attendeePhone',
-      title: 'Attendee Phone',
-      type: 'short-input',
-      placeholder: 'International format (e.g., +1234567890)',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-    },
-    {
-      id: 'guests',
-      title: 'Guests',
-      type: 'short-input',
-      placeholder: 'Comma-separated email addresses',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-    },
-    {
-      id: 'lengthInMinutes',
-      title: 'Duration (minutes)',
-      type: 'short-input',
-      placeholder: 'Override event duration (optional)',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-    },
-    {
-      id: 'metadata',
-      title: 'Metadata',
-      type: 'code',
-      language: 'json',
-      placeholder: '{"key": "value"}',
-      condition: { field: 'operation', value: 'calcom_create_booking' },
-    },
-
-    // === Get/Cancel/Reschedule/Confirm/Decline Booking fields ===
-    {
-      id: 'bookingUid',
-      title: 'Booking UID',
-      type: 'short-input',
-      placeholder: 'Enter booking UID',
-      condition: {
-        field: 'operation',
-        value: [
-          'calcom_get_booking',
-          'calcom_cancel_booking',
-          'calcom_reschedule_booking',
-          'calcom_confirm_booking',
-          'calcom_decline_booking',
-        ],
-      },
-      required: {
-        field: 'operation',
-        value: [
-          'calcom_get_booking',
-          'calcom_cancel_booking',
-          'calcom_reschedule_booking',
-          'calcom_confirm_booking',
-          'calcom_decline_booking',
-        ],
-      },
-    },
-    {
-      id: 'cancellationReason',
-      title: 'Cancellation Reason',
-      type: 'long-input',
-      placeholder: 'Reason for cancellation (optional)',
-      rows: 3,
-      condition: { field: 'operation', value: 'calcom_cancel_booking' },
-    },
-    {
-      id: 'reschedulingReason',
-      title: 'Rescheduling Reason',
-      type: 'long-input',
-      placeholder: 'Reason for rescheduling (optional)',
-      rows: 3,
-      condition: { field: 'operation', value: 'calcom_reschedule_booking' },
-    },
-
-    // === List Bookings filters ===
-    {
-      id: 'bookingStatus',
-      title: 'Status',
-      type: 'dropdown',
-      options: [
-        { label: 'All', id: '' },
-        { label: 'Upcoming', id: 'upcoming' },
-        { label: 'Recurring', id: 'recurring' },
-        { label: 'Past', id: 'past' },
-        { label: 'Cancelled', id: 'cancelled' },
-        { label: 'Unconfirmed', id: 'unconfirmed' },
-      ],
-      condition: { field: 'operation', value: 'calcom_list_bookings' },
-    },
-
-    // === Event Type fields ===
-    {
-      id: 'eventTypeIdParam',
-      title: 'Event Type ID',
-      type: 'short-input',
-      placeholder: 'Enter event type ID',
-      condition: {
-        field: 'operation',
-        value: ['calcom_get_event_type', 'calcom_update_event_type', 'calcom_delete_event_type'],
-      },
-      required: {
-        field: 'operation',
-        value: ['calcom_get_event_type', 'calcom_update_event_type', 'calcom_delete_event_type'],
-      },
-    },
-    {
-      id: 'title',
-      title: 'Title',
-      type: 'short-input',
-      placeholder: 'Event type title',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-      required: { field: 'operation', value: 'calcom_create_event_type' },
-    },
-    {
-      id: 'slug',
-      title: 'Slug',
-      type: 'short-input',
-      placeholder: 'URL-friendly identifier (e.g., 30-min-meeting)',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-      required: { field: 'operation', value: 'calcom_create_event_type' },
-    },
-    {
-      id: 'eventLength',
-      title: 'Duration (minutes)',
-      type: 'short-input',
-      placeholder: 'Event duration in minutes (e.g., 30)',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-      required: { field: 'operation', value: 'calcom_create_event_type' },
-    },
-    {
-      id: 'description',
-      title: 'Description',
-      type: 'long-input',
-      placeholder: 'Event type description',
-      rows: 3,
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-    {
-      id: 'slotInterval',
-      title: 'Slot Interval (minutes)',
-      type: 'short-input',
-      placeholder: 'Minutes between available slots',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-    {
-      id: 'minimumBookingNotice',
-      title: 'Minimum Notice (minutes)',
-      type: 'short-input',
-      placeholder: 'Minimum advance notice required',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-    {
-      id: 'beforeEventBuffer',
-      title: 'Buffer Before (minutes)',
-      type: 'short-input',
-      placeholder: 'Buffer time before event',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-    {
-      id: 'afterEventBuffer',
-      title: 'Buffer After (minutes)',
-      type: 'short-input',
-      placeholder: 'Buffer time after event',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-    {
-      id: 'eventTypeScheduleId',
-      title: 'Schedule ID',
-      type: 'short-input',
-      placeholder: 'Assign to specific schedule (optional)',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-    {
-      id: 'disableGuests',
-      title: 'Disable Guests',
-      type: 'switch',
-      description: 'Prevent attendees from adding guests',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_event_type', 'calcom_update_event_type'],
-      },
-    },
-
-    // === Schedule fields ===
-    {
-      id: 'scheduleId',
-      title: 'Schedule ID',
-      type: 'short-input',
-      placeholder: 'Enter schedule ID',
-      condition: {
-        field: 'operation',
-        value: ['calcom_get_schedule', 'calcom_update_schedule', 'calcom_delete_schedule'],
-      },
-      required: {
-        field: 'operation',
-        value: ['calcom_get_schedule', 'calcom_update_schedule', 'calcom_delete_schedule'],
-      },
-    },
-    {
-      id: 'scheduleName',
-      title: 'Name',
-      type: 'short-input',
-      placeholder: 'Schedule name (e.g., Working Hours)',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_schedule', 'calcom_update_schedule'],
-      },
-      required: { field: 'operation', value: 'calcom_create_schedule' },
-    },
-    {
-      id: 'timeZone',
-      title: 'Time Zone',
-      type: 'short-input',
-      placeholder: 'e.g., America/New_York',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_schedule', 'calcom_update_schedule', 'calcom_get_slots'],
-      },
-      required: { field: 'operation', value: 'calcom_create_schedule' },
-    },
-    {
-      id: 'isDefault',
-      title: 'Default Schedule',
-      type: 'switch',
-      description: 'Set as the default schedule',
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_schedule', 'calcom_update_schedule'],
-      },
-    },
-    {
-      id: 'availability',
-      title: 'Availability',
-      type: 'code',
-      language: 'json',
-      placeholder: `[
-  {
-    "days": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
-    "startTime": "09:00",
-    "endTime": "17:00"
-  }
-]`,
-      condition: {
-        field: 'operation',
-        value: ['calcom_create_schedule', 'calcom_update_schedule'],
-      },
-      wandConfig: {
-        enabled: true,
-        prompt: `Generate a Cal.com availability JSON array based on the user's description.
-
-Each availability object has:
-- days: Array of weekday names (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday)
-- startTime: HH:MM format (24-hour)
-- endTime: HH:MM format (24-hour)
-
-Example for "9-5 weekdays":
-[{"days": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"], "startTime": "09:00", "endTime": "17:00"}]
-
-Example for "mornings only, Monday and Wednesday":
-[{"days": ["Monday", "Wednesday"], "startTime": "08:00", "endTime": "12:00"}]
-
-Return ONLY valid JSON - no explanations.`,
-        placeholder: 'Describe your availability (e.g., "9-5 weekdays")...',
-        generationType: 'json-object',
-      },
-    },
-
-    // === Slots fields ===
-    {
-      id: 'eventTypeSlug',
-      title: 'Event Type Slug',
-      type: 'short-input',
-      placeholder: 'Event type slug (alternative to ID)',
-      condition: { field: 'operation', value: 'calcom_get_slots' },
-    },
-    {
-      id: 'username',
-      title: 'Username',
-      type: 'short-input',
-      placeholder: 'Cal.com username (required with slug)',
-      condition: { field: 'operation', value: 'calcom_get_slots' },
-    },
-    {
-      id: 'duration',
-      title: 'Duration (minutes)',
-      type: 'short-input',
-      placeholder: 'Slot duration (optional)',
-      condition: { field: 'operation', value: 'calcom_get_slots' },
-    },
-
-    // === List Event Types sorting ===
-    {
-      id: 'sortCreatedAt',
-      title: 'Sort by Created',
-      type: 'dropdown',
-      options: [
-        { label: 'None', id: '' },
-        { label: 'Ascending', id: 'asc' },
-        { label: 'Descending', id: 'desc' },
-      ],
-      condition: { field: 'operation', value: 'calcom_list_event_types' },
-    },
-    // Trigger SubBlocks
-    ...getTrigger('calcom_booking_created').subBlocks,
-    ...getTrigger('calcom_booking_cancelled').subBlocks,
-    ...getTrigger('calcom_booking_rescheduled').subBlocks,
-    ...getTrigger('calcom_booking_requested').subBlocks,
-    ...getTrigger('calcom_booking_rejected').subBlocks,
-    ...getTrigger('calcom_booking_paid').subBlocks,
-    ...getTrigger('calcom_meeting_ended').subBlocks,
-    ...getTrigger('calcom_recording_ready').subBlocks,
-    ...getTrigger('calcom_webhook').subBlocks,
-  ],
-  tools: {
-    access: [
-      'calcom_create_booking',
-      'calcom_get_booking',
-      'calcom_list_bookings',
-      'calcom_cancel_booking',
-      'calcom_reschedule_booking',
-      'calcom_confirm_booking',
-      'calcom_decline_booking',
-      'calcom_create_event_type',
-      'calcom_get_event_type',
-      'calcom_list_event_types',
-      'calcom_update_event_type',
-      'calcom_delete_event_type',
-      'calcom_create_schedule',
-      'calcom_get_schedule',
-      'calcom_list_schedules',
-      'calcom_update_schedule',
-      'calcom_delete_schedule',
-      'calcom_get_default_schedule',
-      'calcom_get_slots',
-    ],
-    config: {
-      tool: (params) => params.operation || 'calcom_list_bookings',
-      params: (params) => {
-        const {
-          operation,
-          attendeeName,
-          attendeeEmail,
-          attendeeTimeZone,
-          attendeePhone,
-          guests,
-          metadata,
-          availability,
-          eventTypeIdParam,
-          eventTypeId,
-          bookingStatus,
-          eventLength,
-          scheduleName,
-          eventTypeScheduleId,
-          ...rest
-        } = params
-
-        const result: Record<string, unknown> = { ...rest }
-
-        if (eventTypeId) {
-          result.eventTypeId = Number(eventTypeId)
-        }
-
-        if (operation === 'calcom_create_booking') {
-          result.attendee = {
-            name: attendeeName,
-            ...(attendeeEmail && { email: attendeeEmail }),
-            timeZone: attendeeTimeZone,
-            ...(attendeePhone && { phoneNumber: attendeePhone }),
-          }
-          result.attendeeName = undefined
-          result.attendeeEmail = undefined
-          result.attendeeTimeZone = undefined
-          result.attendeePhone = undefined
-
-          if (guests) {
-            result.guests = guests.split(',').map((g: string) => g.trim())
-          }
-        }
-
-        if (metadata) {
-          try {
-            result.metadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata
-          } catch {
-            throw new Error('Invalid JSON for metadata')
-          }
-        }
-
-        if (availability) {
-          try {
-            result.availability =
-              typeof availability === 'string' ? JSON.parse(availability) : availability
-          } catch {
-            throw new Error('Invalid JSON for availability')
-          }
-        }
-
-        if (eventTypeIdParam) {
-          result.eventTypeId = Number(eventTypeIdParam)
-        }
-
-        if (bookingStatus) {
-          result.status = bookingStatus
-        }
-
-        if (eventLength) {
-          result.lengthInMinutes = Number(eventLength)
-        }
-
-        if (scheduleName) {
-          result.name = scheduleName
-        }
-
-        if (eventTypeScheduleId) {
-          result.scheduleId = Number(eventTypeScheduleId)
-        }
-
-        return result
-      },
-    },
-  },
-  inputs: {
-    operation: { type: 'string', description: 'Operation to perform' },
-    credential: { type: 'string', description: 'Cal.com OAuth credential' },
-    eventTypeId: { type: 'number', description: 'Event type ID' },
-    start: { type: 'string', description: 'Start time (ISO 8601)' },
-    end: { type: 'string', description: 'End time (ISO 8601)' },
-    attendeeName: { type: 'string', description: 'Attendee name' },
-    attendeeEmail: { type: 'string', description: 'Attendee email' },
-    attendeeTimeZone: { type: 'string', description: 'Attendee time zone' },
-    attendeePhone: { type: 'string', description: 'Attendee phone number' },
-    guests: { type: 'string', description: 'Comma-separated guest emails' },
-    lengthInMinutes: { type: 'number', description: 'Duration override in minutes' },
-    metadata: { type: 'json', description: 'Custom metadata object' },
-    bookingUid: { type: 'string', description: 'Booking UID' },
-    cancellationReason: { type: 'string', description: 'Reason for cancellation' },
-    reschedulingReason: { type: 'string', description: 'Reason for rescheduling' },
-    bookingStatus: { type: 'string', description: 'Filter by booking status' },
-    eventTypeIdParam: { type: 'number', description: 'Event type ID for get/update/delete' },
-    title: { type: 'string', description: 'Event type title' },
-    slug: { type: 'string', description: 'URL-friendly slug' },
-    eventLength: { type: 'number', description: 'Event duration in minutes' },
-    description: { type: 'string', description: 'Event type description' },
-    slotInterval: { type: 'number', description: 'Minutes between available slots' },
-    minimumBookingNotice: { type: 'number', description: 'Minimum advance notice' },
-    beforeEventBuffer: { type: 'number', description: 'Buffer before event' },
-    afterEventBuffer: { type: 'number', description: 'Buffer after event' },
-    eventTypeScheduleId: { type: 'number', description: 'Schedule ID for event type' },
-    disableGuests: { type: 'boolean', description: 'Disable guest additions' },
-    sortCreatedAt: { type: 'string', description: 'Sort order for event types' },
-    scheduleId: { type: 'number', description: 'Schedule ID' },
-    scheduleName: { type: 'string', description: 'Schedule name' },
-    timeZone: { type: 'string', description: 'Time zone' },
-    isDefault: { type: 'boolean', description: 'Set as default schedule' },
-    availability: { type: 'json', description: 'Availability configuration' },
-    eventTypeSlug: { type: 'string', description: 'Event type slug' },
-    username: { type: 'string', description: 'Cal.com username' },
-    duration: { type: 'number', description: 'Slot duration in minutes' },
-  },
-  outputs: {
-    success: { type: 'boolean', description: 'Whether operation succeeded' },
-    bookingUid: { type: 'string', description: 'Booking unique identifier' },
-    bookingId: { type: 'number', description: 'Booking ID' },
-    status: { type: 'string', description: 'Booking or event status' },
-    title: { type: 'string', description: 'Booking or event type title' },
-    startTime: { type: 'string', description: 'Booking start time (ISO 8601)' },
-    endTime: { type: 'string', description: 'Booking end time (ISO 8601)' },
-    attendees: { type: 'json', description: 'List of attendees' },
-    hosts: { type: 'json', description: 'List of hosts' },
-    location: { type: 'string', description: 'Meeting location' },
-    meetingUrl: { type: 'string', description: 'Video meeting URL' },
-    bookings: { type: 'json', description: 'List of bookings' },
-    eventTypes: { type: 'json', description: 'List of event types' },
-    schedules: { type: 'json', description: 'List of schedules' },
-    slots: { type: 'json', description: 'Available time slots' },
-    id: { type: 'number', description: 'Event type or schedule ID' },
-    slug: { type: 'string', description: 'Event type slug' },
-    lengthInMinutes: { type: 'number', description: 'Event duration' },
-    description: { type: 'string', description: 'Event type description' },
-    name: { type: 'string', description: 'Schedule name' },
-    timeZone: { type: 'string', description: 'Schedule time zone' },
-    isDefault: { type: 'boolean', description: 'Whether schedule is default' },
-    availability: { type: 'json', description: 'Availability configuration' },
-    deleted: { type: 'boolean', description: 'Whether deletion succeeded' },
-    message: { type: 'string', description: 'Status or error message' },
-    triggerEvent: { type: 'string', description: 'Webhook event type' },
-    createdAt: { type: 'string', description: 'Webhook event timestamp' },
-    payload: { type: 'json', description: 'Complete webhook payload data' },
-  },
-  triggers: {
-    enabled: true,
-    available: [
-      'calcom_booking_created',
-      'calcom_booking_cancelled',
-      'calcom_booking_rescheduled',
-      'calcom_booking_requested',
-      'calcom_booking_rejected',
-      'calcom_booking_paid',
-      'calcom_meeting_ended',
-      'calcom_recording_ready',
-      'calcom_webhook',
-    ],
-  },
-}

apps/sim/blocks/registry.ts

@@ -9,7 +9,6 @@ import { ApolloBlock } from '@/blocks/blocks/apollo'
 import { ArxivBlock } from '@/blocks/blocks/arxiv'
 import { AsanaBlock } from '@/blocks/blocks/asana'
 import { BrowserUseBlock } from '@/blocks/blocks/browser_use'
-import { CalComBlock } from '@/blocks/blocks/calcom'
 import { CalendlyBlock } from '@/blocks/blocks/calendly'
 import { ChatTriggerBlock } from '@/blocks/blocks/chat_trigger'
 import { CirclebackBlock } from '@/blocks/blocks/circleback'
@@ -166,7 +165,6 @@ export const registry: Record<string, BlockConfig> = {
   arxiv: ArxivBlock,
   asana: AsanaBlock,
   browser_use: BrowserUseBlock,
-  calcom: CalComBlock,
   calendly: CalendlyBlock,
   chat_trigger: ChatTriggerBlock,
   circleback: CirclebackBlock,

apps/sim/components/emcn/components/code/code.css

@@ -37,7 +37,7 @@
 .code-editor-theme .token.char,
 .code-editor-theme .token.builtin,
 .code-editor-theme .token.inserted {
-  color: #b45309 !important;
+  color: #dc2626 !important;
 }
 
 .code-editor-theme .token.operator,
@@ -49,7 +49,7 @@
 .code-editor-theme .token.atrule,
 .code-editor-theme .token.attr-value,
 .code-editor-theme .token.keyword {
-  color: #2f55ff !important;
+  color: #2563eb !important;
 }
 
 .code-editor-theme .token.function,
@@ -119,7 +119,7 @@
 .dark .code-editor-theme .token.atrule,
 .dark .code-editor-theme .token.attr-value,
 .dark .code-editor-theme .token.keyword {
-  color: #2fa1ff !important;
+  color: #4db8ff !important;
 }
 
 .dark .code-editor-theme .token.function,

apps/sim/components/emcn/components/popover/popover.tsx

@@ -513,10 +513,18 @@ const PopoverContent = React.forwardRef<
       return () => window.removeEventListener('keydown', handleKeyDown, true)
     }, [context])
 
-    // Note: scrollIntoView for keyboard navigation is intentionally disabled here.
-    // Components using Popover (like TagDropdown) should handle their own scroll
-    // management to avoid conflicts between the popover's internal selection index
-    // and the component's custom navigation state.
+    React.useEffect(() => {
+      const content = contentRef.current
+      if (!content || !context?.isKeyboardNav || context.selectedIndex < 0) return
+
+      const items = content.querySelectorAll<HTMLElement>(
+        '[role="menuitem"]:not([aria-disabled="true"])'
+      )
+      const selectedItem = items[context.selectedIndex]
+      if (selectedItem) {
+        selectedItem.scrollIntoView({ block: 'nearest', behavior: 'smooth' })
+      }
+    }, [context?.selectedIndex, context?.isKeyboardNav])
 
     const hasUserWidthConstraint =
       maxWidth !== undefined ||
@@ -707,8 +715,7 @@ const PopoverItem = React.forwardRef<HTMLDivElement, PopoverItemProps>(
 
     const handleMouseEnter = (e: React.MouseEvent<HTMLDivElement>) => {
       context?.setLastHoveredItem(null)
-      // Don't update selection during keyboard navigation to prevent scroll jumps
-      if (itemIndex >= 0 && context && !context.isKeyboardNav) {
+      if (itemIndex >= 0 && context) {
         context.setSelectedIndex(itemIndex)
       }
       onMouseEnter?.(e)
@@ -889,8 +896,7 @@ const PopoverFolder = React.forwardRef<HTMLDivElement, PopoverFolderProps>(
     }
 
     const handleMouseEnter = () => {
-      // Don't update selection during keyboard navigation to prevent scroll jumps
-      if (itemIndex >= 0 && !isKeyboardNav) {
+      if (itemIndex >= 0) {
         setSelectedIndex(itemIndex)
       }
 

apps/sim/components/emcn/icons/index.ts

@@ -21,7 +21,7 @@ export { Loader } from './loader'
 export { MoreHorizontal } from './more-horizontal'
 export { NoWrap } from './no-wrap'
 export { PanelLeft } from './panel-left'
-export { Play, PlayOutline } from './play'
+export { Play } from './play'
 export { Redo } from './redo'
 export { Rocket } from './rocket'
 export { Trash } from './trash'

apps/sim/components/emcn/icons/play.tsx

@@ -1,7 +1,7 @@
 import type { SVGProps } from 'react'
 
 /**
- * Play icon component (filled/solid version)
+ * Play icon component
  * @param props - SVG properties including className, fill, etc.
  */
 export function Play(props: SVGProps<SVGSVGElement>) {
@@ -21,27 +21,3 @@ export function Play(props: SVGProps<SVGSVGElement>) {
     </svg>
   )
 }
-
-/**
- * Play icon component (stroke/outline version, matches lucide style)
- * Uses 24x24 viewBox and strokeWidth 2 for consistency with other icons.
- * @param props - SVG properties including className, stroke, etc.
- */
-export function PlayOutline(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg
-      width='24'
-      height='24'
-      viewBox='0 0 24 24'
-      fill='none'
-      stroke='currentColor'
-      strokeWidth='2'
-      strokeLinecap='round'
-      strokeLinejoin='round'
-      xmlns='http://www.w3.org/2000/svg'
-      {...props}
-    >
-      <path d='M14.7175 4.07175C16.6036 5.37051 18.0001 6.39111 19.0000 7.32600C20.0087 8.26733 20.9617 9.25123 21.3031 10.5484C21.5534 11.4996 21.5534 12.5003 21.3031 13.4515C20.9617 14.7487 20.0087 15.7326 19.0000 16.6739C18.0001 17.6088 16.6037 18.6294 14.7176 19.9281C12.9093 21.1827 11.0470 22.2407 9.6333 22.8420C8.2082 23.4482 6.9090 23.7554 5.6463 23.3976C4.6383 23.1346 3.7940 22.6355 3.1138 21.9492C2.1907 21.0179 1.9001 19.7306 1.7248 18.1814C1.5507 16.6436 1.5507 14.6305 1.5508 12.0701V11.9298C1.5507 9.36936 1.5507 7.35626 1.7248 5.81844C1.9001 4.26926 2.1907 2.982 3.1138 2.05063C3.7940 1.36438 4.6383 0.865267 5.6463 0.602306C6.9090 0.244489 8.2082 0.551707 9.6333 1.15785C11.0470 1.75916 12.9092 2.81712 14.7175 4.07175Z' />
-    </svg>
-  )
-}

apps/sim/components/icons.tsx

@@ -5113,42 +5113,3 @@ export function PulseIcon(props: SVGProps<SVGSVGElement>) {
     </svg>
   )
 }
-
-export function CalComIcon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg
-      {...props}
-      width='101'
-      height='22'
-      viewBox='0 0 101 22'
-      fill='currentColor'
-      xmlns='http://www.w3.org/2000/svg'
-    >
-      <path
-        d='M10.0582 20.817C4.32115 20.817 0 16.2763 0 10.6704C0 5.04589 4.1005 0.467773 10.0582 0.467773C13.2209 0.467773 15.409 1.43945 17.1191 3.66311L14.3609 5.96151C13.2025 4.72822 11.805 4.11158 10.0582 4.11158C6.17833 4.11158 4.04533 7.08268 4.04533 10.6704C4.04533 14.2582 6.38059 17.1732 10.0582 17.1732C11.7866 17.1732 13.2577 16.5566 14.4161 15.3233L17.1375 17.7151C15.501 19.8453 13.2577 20.817 10.0582 20.817Z'
-        fill='#292929'
-      />
-      <path
-        d='M29.0161 5.88601H32.7304V20.4612H29.0161V18.331C28.2438 19.8446 26.9566 20.8536 24.4927 20.8536C20.5577 20.8536 17.4133 17.4341 17.4133 13.2297C17.4133 9.02528 20.5577 5.60571 24.4927 5.60571C26.9383 5.60571 28.2438 6.61477 29.0161 8.12835V5.88601ZM29.1264 13.2297C29.1264 10.95 27.5634 9.06266 25.0995 9.06266C22.7274 9.06266 21.1828 10.9686 21.1828 13.2297C21.1828 15.4346 22.7274 17.3967 25.0995 17.3967C27.5451 17.3967 29.1264 15.4907 29.1264 13.2297Z'
-        fill='#292929'
-      />
-      <path d='M35.3599 0H39.0742V20.4427H35.3599V0Z' fill='#292929' />
-      <path
-        d='M40.7291 18.5182C40.7291 17.3223 41.6853 16.3132 42.9908 16.3132C44.2964 16.3132 45.2158 17.3223 45.2158 18.5182C45.2158 19.7515 44.278 20.7605 42.9908 20.7605C41.7037 20.7605 40.7291 19.7515 40.7291 18.5182Z'
-        fill='#292929'
-      />
-      <path
-        d='M59.4296 18.1068C58.0505 19.7885 55.9543 20.8536 53.4719 20.8536C49.0404 20.8536 45.7858 17.4341 45.7858 13.2297C45.7858 9.02528 49.0404 5.60571 53.4719 5.60571C55.8623 5.60571 57.9402 6.61477 59.3193 8.20309L56.4508 10.6136C55.7336 9.71667 54.7958 9.04397 53.4719 9.04397C51.0999 9.04397 49.5553 10.95 49.5553 13.211C49.5553 15.472 51.0999 17.378 53.4719 17.378C54.9062 17.378 55.8991 16.6306 56.6346 15.6215L59.4296 18.1068Z'
-        fill='#292929'
-      />
-      <path
-        d='M59.7422 13.2297C59.7422 9.02528 62.9968 5.60571 67.4283 5.60571C71.8598 5.60571 75.1144 9.02528 75.1144 13.2297C75.1144 17.4341 71.8598 20.8536 67.4283 20.8536C62.9968 20.8349 59.7422 17.4341 59.7422 13.2297ZM71.3449 13.2297C71.3449 10.95 69.8003 9.06266 67.4283 9.06266C65.0563 9.04397 63.5117 10.95 63.5117 13.2297C63.5117 15.4907 65.0563 17.3967 67.4283 17.3967C69.8003 17.3967 71.3449 15.4907 71.3449 13.2297Z'
-        fill='#292929'
-      />
-      <path
-        d='M100.232 11.5482V20.4428H96.518V12.4638C96.518 9.94119 95.3412 8.85739 93.576 8.85739C91.921 8.85739 90.7442 9.67958 90.7442 12.4638V20.4428H87.0299V12.4638C87.0299 9.94119 85.8346 8.85739 84.0878 8.85739C82.4329 8.85739 80.9802 9.67958 80.9802 12.4638V20.4428H77.2659V5.8676H80.9802V7.88571C81.7525 6.31607 83.15 5.53125 85.3014 5.53125C87.3425 5.53125 89.0525 6.5403 89.9903 8.24074C90.9281 6.50293 92.3072 5.53125 94.8079 5.53125C97.8603 5.54994 100.232 7.86702 100.232 11.5482Z'
-        fill='#292929'
-      />
-    </svg>
-  )
-}

apps/sim/executor/dag/builder.ts

@@ -33,15 +33,6 @@ export interface DAG {
   parallelConfigs: Map<string, SerializedParallel>
 }
 
-export interface DAGBuildOptions {
-  /** Trigger block ID to start path construction from */
-  triggerBlockId?: string
-  /** Saved incoming edges from snapshot for resumption */
-  savedIncomingEdges?: Record<string, string[]>
-  /** Include all enabled blocks instead of only those reachable from trigger */
-  includeAllBlocks?: boolean
-}
-
 export class DAGBuilder {
   private pathConstructor = new PathConstructor()
   private loopConstructor = new LoopConstructor()
@@ -49,9 +40,11 @@ export class DAGBuilder {
   private nodeConstructor = new NodeConstructor()
   private edgeConstructor = new EdgeConstructor()
 
-  build(workflow: SerializedWorkflow, options: DAGBuildOptions = {}): DAG {
-    const { triggerBlockId, savedIncomingEdges, includeAllBlocks } = options
-
+  build(
+    workflow: SerializedWorkflow,
+    triggerBlockId?: string,
+    savedIncomingEdges?: Record<string, string[]>
+  ): DAG {
     const dag: DAG = {
       nodes: new Map(),
       loopConfigs: new Map(),
@@ -60,7 +53,7 @@ export class DAGBuilder {
 
     this.initializeConfigs(workflow, dag)
 
-    const reachableBlocks = this.pathConstructor.execute(workflow, triggerBlockId, includeAllBlocks)
+    const reachableBlocks = this.pathConstructor.execute(workflow, triggerBlockId)
 
     this.loopConstructor.execute(dag, reachableBlocks)
     this.parallelConstructor.execute(dag, reachableBlocks)

apps/sim/executor/dag/construction/paths.ts

@@ -6,16 +6,7 @@ import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 const logger = createLogger('PathConstructor')
 
 export class PathConstructor {
-  execute(
-    workflow: SerializedWorkflow,
-    triggerBlockId?: string,
-    includeAllBlocks?: boolean
-  ): Set<string> {
-    // For run-from-block mode, include all enabled blocks regardless of trigger reachability
-    if (includeAllBlocks) {
-      return this.getAllEnabledBlocks(workflow)
-    }
-
+  execute(workflow: SerializedWorkflow, triggerBlockId?: string): Set<string> {
     const resolvedTriggerId = this.findTriggerBlock(workflow, triggerBlockId)
 
     if (!resolvedTriggerId) {

apps/sim/executor/execution/block-executor.ts

@@ -4,7 +4,6 @@ import {
   containsUserFileWithMetadata,
   hydrateUserFilesWithBase64,
 } from '@/lib/uploads/utils/user-file-base64.server'
-import { sanitizeInputFormat, sanitizeTools } from '@/lib/workflows/comparison/normalize'
 import {
   BlockType,
   buildResumeApiUrl,
@@ -35,7 +34,6 @@ import { validateBlockType } from '@/executor/utils/permission-check'
 import type { VariableResolver } from '@/executor/variables/resolver'
 import type { SerializedBlock } from '@/serializer/types'
 import type { SubflowType } from '@/stores/workflows/workflow/types'
-import { SYSTEM_SUBBLOCK_IDS } from '@/triggers/constants'
 
 const logger = createLogger('BlockExecutor')
 
@@ -89,7 +87,7 @@ export class BlockExecutor {
       resolvedInputs = this.resolver.resolveInputs(ctx, node.id, block.config.params, block)
 
       if (blockLog) {
-        blockLog.input = this.sanitizeInputsForLog(resolvedInputs)
+        blockLog.input = this.parseJsonInputs(resolvedInputs)
       }
     } catch (error) {
       cleanupSelfReference?.()
@@ -152,9 +150,6 @@ export class BlockExecutor {
         blockLog.durationMs = duration
         blockLog.success = true
         blockLog.output = filterOutputForLog(block.metadata?.id || '', normalizedOutput, { block })
-        if (normalizedOutput.childTraceSpans && Array.isArray(normalizedOutput.childTraceSpans)) {
-          blockLog.childTraceSpans = normalizedOutput.childTraceSpans
-        }
       }
 
       this.state.setBlockOutput(node.id, normalizedOutput, duration)
@@ -167,7 +162,7 @@ export class BlockExecutor {
           ctx,
           node,
           block,
-          this.sanitizeInputsForLog(resolvedInputs),
+          this.parseJsonInputs(resolvedInputs),
           displayOutput,
           duration
         )
@@ -246,12 +241,8 @@ export class BlockExecutor {
       blockLog.durationMs = duration
       blockLog.success = false
       blockLog.error = errorMessage
-      blockLog.input = this.sanitizeInputsForLog(input)
+      blockLog.input = this.parseJsonInputs(input)
       blockLog.output = filterOutputForLog(block.metadata?.id || '', errorOutput, { block })
-
-      if (errorOutput.childTraceSpans && Array.isArray(errorOutput.childTraceSpans)) {
-        blockLog.childTraceSpans = errorOutput.childTraceSpans
-      }
     }
 
     logger.error(
@@ -269,7 +260,7 @@ export class BlockExecutor {
         ctx,
         node,
         block,
-        this.sanitizeInputsForLog(input),
+        this.parseJsonInputs(input),
         displayOutput,
         duration
       )
@@ -361,41 +352,29 @@ export class BlockExecutor {
   }
 
   /**
-   * Sanitizes inputs for log display.
-   * - Filters out system fields (UI-only, readonly, internal flags)
-   * - Removes UI state from inputFormat items (e.g., collapsed)
-   * - Parses JSON strings to objects for readability
+   * Parse JSON string inputs to objects for log display only.
+   * Attempts to parse any string that looks like JSON.
    * Returns a new object - does not mutate the original inputs.
    */
-  private sanitizeInputsForLog(inputs: Record<string, any>): Record<string, any> {
-    const result: Record<string, any> = {}
+  private parseJsonInputs(inputs: Record<string, any>): Record<string, any> {
+    let result = inputs
+    let hasChanges = false
 
     for (const [key, value] of Object.entries(inputs)) {
-      if (SYSTEM_SUBBLOCK_IDS.includes(key) || key === 'triggerMode') {
-        continue
-      }
-
-      if (key === 'inputFormat' && Array.isArray(value)) {
-        result[key] = sanitizeInputFormat(value)
-        continue
-      }
-
-      if (key === 'tools' && Array.isArray(value)) {
-        result[key] = sanitizeTools(value)
-        continue
-      }
-
       // isJSONString is a quick heuristic (checks for { or [), not a validator.
       // Invalid JSON is safely caught below - this just avoids JSON.parse on every string.
-      if (typeof value === 'string' && isJSONString(value)) {
-        try {
-          result[key] = JSON.parse(value.trim())
-        } catch {
-          // Not valid JSON, keep original string
-          result[key] = value
+      if (typeof value !== 'string' || !isJSONString(value)) {
+        continue
+      }
+
+      try {
+        if (!hasChanges) {
+          result = { ...inputs }
+          hasChanges = true
         }
-      } else {
-        result[key] = value
+        result[key] = JSON.parse(value.trim())
+      } catch {
+        // Not valid JSON, keep original string
       }
     }
 

apps/sim/executor/execution/engine.ts

@@ -26,7 +26,6 @@ export class ExecutionEngine {
   private allowResumeTriggers: boolean
   private cancelledFlag = false
   private errorFlag = false
-  private stoppedEarlyFlag = false
   private executionError: Error | null = null
   private lastCancellationCheck = 0
   private readonly useRedisCancellation: boolean
@@ -106,7 +105,7 @@ export class ExecutionEngine {
       this.initializeQueue(triggerBlockId)
 
       while (this.hasWork()) {
-        if ((await this.checkCancellation()) || this.errorFlag || this.stoppedEarlyFlag) {
+        if ((await this.checkCancellation()) || this.errorFlag) {
           break
         }
         await this.processQueue()
@@ -260,16 +259,6 @@ export class ExecutionEngine {
   }
 
   private initializeQueue(triggerBlockId?: string): void {
-    if (this.context.runFromBlockContext) {
-      const { startBlockId } = this.context.runFromBlockContext
-      logger.info('Initializing queue for run-from-block mode', {
-        startBlockId,
-        dirtySetSize: this.context.runFromBlockContext.dirtySet.size,
-      })
-      this.addToQueue(startBlockId)
-      return
-    }
-
     const pendingBlocks = this.context.metadata.pendingBlocks
     const remainingEdges = (this.context.metadata as any).remainingEdges
 
@@ -396,17 +385,6 @@ export class ExecutionEngine {
       this.finalOutput = output
     }
 
-    if (this.context.stopAfterBlockId === nodeId) {
-      // For loop/parallel sentinels, only stop if the subflow has fully exited (all iterations done)
-      // shouldContinue: true means more iterations, shouldExit: true means loop is done
-      const shouldContinueLoop = output.shouldContinue === true
-      if (!shouldContinueLoop) {
-        logger.info('Stopping execution after target block', { nodeId })
-        this.stoppedEarlyFlag = true
-        return
-      }
-    }
-
     const readyNodes = this.edgeManager.processOutgoingEdges(node, output, false)
 
     logger.info('Processing outgoing edges', {

apps/sim/executor/execution/executor.ts

@@ -5,31 +5,17 @@ import { BlockExecutor } from '@/executor/execution/block-executor'
 import { EdgeManager } from '@/executor/execution/edge-manager'
 import { ExecutionEngine } from '@/executor/execution/engine'
 import { ExecutionState } from '@/executor/execution/state'
-import type {
-  ContextExtensions,
-  SerializableExecutionState,
-  WorkflowInput,
-} from '@/executor/execution/types'
+import type { ContextExtensions, WorkflowInput } from '@/executor/execution/types'
 import { createBlockHandlers } from '@/executor/handlers/registry'
 import { LoopOrchestrator } from '@/executor/orchestrators/loop'
 import { NodeExecutionOrchestrator } from '@/executor/orchestrators/node'
 import { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
 import type { BlockState, ExecutionContext, ExecutionResult } from '@/executor/types'
-import {
-  computeExecutionSets,
-  type RunFromBlockContext,
-  resolveContainerToSentinelStart,
-  validateRunFromBlock,
-} from '@/executor/utils/run-from-block'
 import {
   buildResolutionFromBlock,
   buildStartBlockOutput,
   resolveExecutorStartBlock,
 } from '@/executor/utils/start-block'
-import {
-  extractLoopIdFromSentinel,
-  extractParallelIdFromSentinel,
-} from '@/executor/utils/subflow-utils'
 import { VariableResolver } from '@/executor/variables/resolver'
 import type { SerializedWorkflow } from '@/serializer/types'
 
@@ -62,10 +48,7 @@ export class DAGExecutor {
 
   async execute(workflowId: string, triggerBlockId?: string): Promise<ExecutionResult> {
     const savedIncomingEdges = this.contextExtensions.dagIncomingEdges
-    const dag = this.dagBuilder.build(this.workflow, {
-      triggerBlockId,
-      savedIncomingEdges,
-    })
+    const dag = this.dagBuilder.build(this.workflow, triggerBlockId, savedIncomingEdges)
     const { context, state } = this.createExecutionContext(workflowId, triggerBlockId)
 
     const resolver = new VariableResolver(this.workflow, this.workflowVariables, state)
@@ -106,156 +89,17 @@ export class DAGExecutor {
     }
   }
 
-  /**
-   * Execute from a specific block using cached outputs for upstream blocks.
-   */
-  async executeFromBlock(
-    workflowId: string,
-    startBlockId: string,
-    sourceSnapshot: SerializableExecutionState
-  ): Promise<ExecutionResult> {
-    // Build full DAG with all blocks to compute upstream set for snapshot filtering
-    // includeAllBlocks is needed because the startBlockId might be a trigger not reachable from the main trigger
-    const dag = this.dagBuilder.build(this.workflow, { includeAllBlocks: true })
-
-    const executedBlocks = new Set(sourceSnapshot.executedBlocks)
-    const validation = validateRunFromBlock(startBlockId, dag, executedBlocks)
-    if (!validation.valid) {
-      throw new Error(validation.error)
-    }
-
-    const { dirtySet, upstreamSet, reachableUpstreamSet } = computeExecutionSets(dag, startBlockId)
-    const effectiveStartBlockId = resolveContainerToSentinelStart(startBlockId, dag) ?? startBlockId
-
-    // Extract container IDs from sentinel IDs in reachable upstream set
-    // Use reachableUpstreamSet (not upstreamSet) to preserve sibling branch outputs
-    // Example: A->C, B->C where C references A.result || B.result
-    // When running from A, B's output should be preserved for C to reference
-    const reachableContainerIds = new Set<string>()
-    for (const nodeId of reachableUpstreamSet) {
-      const loopId = extractLoopIdFromSentinel(nodeId)
-      if (loopId) reachableContainerIds.add(loopId)
-      const parallelId = extractParallelIdFromSentinel(nodeId)
-      if (parallelId) reachableContainerIds.add(parallelId)
-    }
-
-    // Filter snapshot to include all blocks reachable from dirty blocks
-    // This preserves sibling branch outputs that dirty blocks may reference
-    const filteredBlockStates: Record<string, any> = {}
-    for (const [blockId, state] of Object.entries(sourceSnapshot.blockStates)) {
-      if (reachableUpstreamSet.has(blockId) || reachableContainerIds.has(blockId)) {
-        filteredBlockStates[blockId] = state
-      }
-    }
-    const filteredExecutedBlocks = sourceSnapshot.executedBlocks.filter(
-      (id) => reachableUpstreamSet.has(id) || reachableContainerIds.has(id)
-    )
-
-    // Filter loop/parallel executions to only include reachable containers
-    const filteredLoopExecutions: Record<string, any> = {}
-    if (sourceSnapshot.loopExecutions) {
-      for (const [loopId, execution] of Object.entries(sourceSnapshot.loopExecutions)) {
-        if (reachableContainerIds.has(loopId)) {
-          filteredLoopExecutions[loopId] = execution
-        }
-      }
-    }
-    const filteredParallelExecutions: Record<string, any> = {}
-    if (sourceSnapshot.parallelExecutions) {
-      for (const [parallelId, execution] of Object.entries(sourceSnapshot.parallelExecutions)) {
-        if (reachableContainerIds.has(parallelId)) {
-          filteredParallelExecutions[parallelId] = execution
-        }
-      }
-    }
-
-    const filteredSnapshot: SerializableExecutionState = {
-      ...sourceSnapshot,
-      blockStates: filteredBlockStates,
-      executedBlocks: filteredExecutedBlocks,
-      loopExecutions: filteredLoopExecutions,
-      parallelExecutions: filteredParallelExecutions,
-    }
-
-    logger.info('Executing from block', {
-      workflowId,
-      startBlockId,
-      effectiveStartBlockId,
-      dirtySetSize: dirtySet.size,
-      upstreamSetSize: upstreamSet.size,
-      reachableUpstreamSetSize: reachableUpstreamSet.size,
-    })
-
-    // Remove incoming edges from non-dirty sources so convergent blocks don't wait for cached upstream
-    for (const nodeId of dirtySet) {
-      const node = dag.nodes.get(nodeId)
-      if (!node) continue
-
-      const nonDirtyIncoming: string[] = []
-      for (const sourceId of node.incomingEdges) {
-        if (!dirtySet.has(sourceId)) {
-          nonDirtyIncoming.push(sourceId)
-        }
-      }
-
-      for (const sourceId of nonDirtyIncoming) {
-        node.incomingEdges.delete(sourceId)
-      }
-    }
-
-    const runFromBlockContext = { startBlockId: effectiveStartBlockId, dirtySet }
-    const { context, state } = this.createExecutionContext(workflowId, undefined, {
-      snapshotState: filteredSnapshot,
-      runFromBlockContext,
-    })
-
-    const resolver = new VariableResolver(this.workflow, this.workflowVariables, state)
-    const loopOrchestrator = new LoopOrchestrator(dag, state, resolver)
-    loopOrchestrator.setContextExtensions(this.contextExtensions)
-    const parallelOrchestrator = new ParallelOrchestrator(dag, state)
-    parallelOrchestrator.setResolver(resolver)
-    parallelOrchestrator.setContextExtensions(this.contextExtensions)
-    const allHandlers = createBlockHandlers()
-    const blockExecutor = new BlockExecutor(allHandlers, resolver, this.contextExtensions, state)
-    const edgeManager = new EdgeManager(dag)
-    loopOrchestrator.setEdgeManager(edgeManager)
-    const nodeOrchestrator = new NodeExecutionOrchestrator(
-      dag,
-      state,
-      blockExecutor,
-      loopOrchestrator,
-      parallelOrchestrator
-    )
-    const engine = new ExecutionEngine(context, dag, edgeManager, nodeOrchestrator)
-
-    return await engine.run()
-  }
-
   private createExecutionContext(
     workflowId: string,
-    triggerBlockId?: string,
-    overrides?: {
-      snapshotState?: SerializableExecutionState
-      runFromBlockContext?: RunFromBlockContext
-    }
+    triggerBlockId?: string
   ): { context: ExecutionContext; state: ExecutionState } {
-    const snapshotState = overrides?.snapshotState ?? this.contextExtensions.snapshotState
+    const snapshotState = this.contextExtensions.snapshotState
     const blockStates = snapshotState?.blockStates
       ? new Map(Object.entries(snapshotState.blockStates))
       : new Map<string, BlockState>()
-    let executedBlocks = snapshotState?.executedBlocks
+    const executedBlocks = snapshotState?.executedBlocks
       ? new Set(snapshotState.executedBlocks)
       : new Set<string>()
-
-    if (overrides?.runFromBlockContext) {
-      const { dirtySet } = overrides.runFromBlockContext
-      executedBlocks = new Set([...executedBlocks].filter((id) => !dirtySet.has(id)))
-      logger.info('Cleared executed status for dirty blocks', {
-        dirtySetSize: dirtySet.size,
-        remainingExecutedBlocks: executedBlocks.size,
-      })
-    }
-
     const state = new ExecutionState(blockStates, executedBlocks)
 
     const context: ExecutionContext = {
@@ -265,7 +109,7 @@ export class DAGExecutor {
       userId: this.contextExtensions.userId,
       isDeployedContext: this.contextExtensions.isDeployedContext,
       blockStates: state.getBlockStates(),
-      blockLogs: overrides?.runFromBlockContext ? [] : (snapshotState?.blockLogs ?? []),
+      blockLogs: snapshotState?.blockLogs ?? [],
       metadata: {
         ...this.contextExtensions.metadata,
         startTime: new Date().toISOString(),
@@ -325,8 +169,6 @@ export class DAGExecutor {
       abortSignal: this.contextExtensions.abortSignal,
       includeFileBase64: this.contextExtensions.includeFileBase64,
       base64MaxBytes: this.contextExtensions.base64MaxBytes,
-      runFromBlockContext: overrides?.runFromBlockContext,
-      stopAfterBlockId: this.contextExtensions.stopAfterBlockId,
     }
 
     if (this.contextExtensions.resumeFromSnapshot) {
@@ -351,15 +193,6 @@ export class DAGExecutor {
         pendingBlocks: context.metadata.pendingBlocks,
         skipStarterBlockInit: true,
       })
-    } else if (overrides?.runFromBlockContext) {
-      // In run-from-block mode, initialize the start block only if it's a regular block
-      // Skip for sentinels/containers (loop/parallel) which aren't real blocks
-      const startBlockId = overrides.runFromBlockContext.startBlockId
-      const isRegularBlock = this.workflow.blocks.some((b) => b.id === startBlockId)
-
-      if (isRegularBlock) {
-        this.initializeStarterBlock(context, state, startBlockId)
-      }
     } else {
       this.initializeStarterBlock(context, state, triggerBlockId)
     }

apps/sim/executor/execution/types.ts

@@ -1,6 +1,5 @@
 import type { Edge } from 'reactflow'
 import type { BlockLog, BlockState, NormalizedBlockOutput } from '@/executor/types'
-import type { RunFromBlockContext } from '@/executor/utils/run-from-block'
 import type { SubflowType } from '@/stores/workflows/workflow/types'
 
 export interface ExecutionMetadata {
@@ -106,17 +105,6 @@ export interface ContextExtensions {
     output: { input?: any; output: NormalizedBlockOutput; executionTime: number },
     iterationContext?: IterationContext
   ) => Promise<void>
-
-  /**
-   * Run-from-block configuration. When provided, executor runs in partial
-   * execution mode starting from the specified block.
-   */
-  runFromBlockContext?: RunFromBlockContext
-
-  /**
-   * Stop execution after this block completes. Used for "run until block" feature.
-   */
-  stopAfterBlockId?: string
 }
 
 export interface WorkflowInput {

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

@@ -118,7 +118,7 @@ describe('WorkflowBlockHandler', () => {
       }
 
       await expect(handler.execute(deepContext, mockBlock, inputs)).rejects.toThrow(
-        '"child-workflow-id" failed: Maximum workflow nesting depth of 10 exceeded'
+        'Error in child workflow "child-workflow-id": Maximum workflow nesting depth of 10 exceeded'
       )
     })
 
@@ -132,7 +132,7 @@ describe('WorkflowBlockHandler', () => {
       })
 
       await expect(handler.execute(mockContext, mockBlock, inputs)).rejects.toThrow(
-        '"non-existent-workflow" failed: Child workflow non-existent-workflow not found'
+        'Error in child workflow "non-existent-workflow": Child workflow non-existent-workflow not found'
       )
     })
 
@@ -142,7 +142,7 @@ describe('WorkflowBlockHandler', () => {
       mockFetch.mockRejectedValueOnce(new Error('Network error'))
 
       await expect(handler.execute(mockContext, mockBlock, inputs)).rejects.toThrow(
-        '"child-workflow-id" failed: Network error'
+        'Error in child workflow "child-workflow-id": Network error'
       )
     })
   })
@@ -212,7 +212,7 @@ describe('WorkflowBlockHandler', () => {
 
       expect(() =>
         (handler as any).mapChildOutputToParent(childResult, 'child-id', 'Child Workflow', 100)
-      ).toThrow('"Child Workflow" failed: Child workflow failed')
+      ).toThrow('Error in child workflow "Child Workflow": Child workflow failed')
 
       try {
         ;(handler as any).mapChildOutputToParent(childResult, 'child-id', 'Child Workflow', 100)

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

@@ -52,11 +52,6 @@ export class WorkflowBlockHandler implements BlockHandler {
       throw new Error('No workflow selected for execution')
     }
 
-    // Initialize with registry name, will be updated with loaded workflow name
-    const { workflows } = useWorkflowRegistry.getState()
-    const workflowMetadata = workflows[workflowId]
-    let childWorkflowName = workflowMetadata?.name || workflowId
-
     try {
       const currentDepth = (ctx.workflowId?.split('_sub_').length || 1) - 1
       if (currentDepth >= DEFAULTS.MAX_WORKFLOW_DEPTH) {
@@ -80,8 +75,9 @@ export class WorkflowBlockHandler implements BlockHandler {
         throw new Error(`Child workflow ${workflowId} not found`)
       }
 
-      // Update with loaded workflow name (more reliable than registry)
-      childWorkflowName = workflowMetadata?.name || childWorkflow.name || 'Unknown Workflow'
+      const { workflows } = useWorkflowRegistry.getState()
+      const workflowMetadata = workflows[workflowId]
+      const childWorkflowName = workflowMetadata?.name || childWorkflow.name || 'Unknown Workflow'
 
       logger.info(
         `Executing child workflow: ${childWorkflowName} (${workflowId}) at depth ${currentDepth}`
@@ -146,6 +142,11 @@ export class WorkflowBlockHandler implements BlockHandler {
     } catch (error: unknown) {
       logger.error(`Error executing child workflow ${workflowId}:`, error)
 
+      const { workflows } = useWorkflowRegistry.getState()
+      const workflowMetadata = workflows[workflowId]
+      const childWorkflowName = workflowMetadata?.name || workflowId
+
+      const originalError = error instanceof Error ? error.message : 'Unknown error'
       let childTraceSpans: WorkflowTraceSpan[] = []
       let executionResult: ExecutionResult | undefined
 
@@ -164,11 +165,8 @@ export class WorkflowBlockHandler implements BlockHandler {
         childTraceSpans = error.childTraceSpans
       }
 
-      // Build a cleaner error message for nested workflow errors
-      const errorMessage = this.buildNestedWorkflowErrorMessage(childWorkflowName, error)
-
       throw new ChildWorkflowError({
-        message: errorMessage,
+        message: `Error in child workflow "${childWorkflowName}": ${originalError}`,
         childWorkflowName,
         childTraceSpans,
         executionResult,
@@ -177,72 +175,6 @@ export class WorkflowBlockHandler implements BlockHandler {
     }
   }
 
-  /**
-   * Builds a cleaner error message for nested workflow errors.
-   * Parses nested error messages to extract workflow chain and root error.
-   */
-  private buildNestedWorkflowErrorMessage(childWorkflowName: string, error: unknown): string {
-    const originalError = error instanceof Error ? error.message : 'Unknown error'
-
-    // Extract any nested workflow names from the error message
-    const { chain, rootError } = this.parseNestedWorkflowError(originalError)
-
-    // Add current workflow to the beginning of the chain
-    chain.unshift(childWorkflowName)
-
-    // If we have a chain (nested workflows), format nicely
-    if (chain.length > 1) {
-      return `Workflow chain: ${chain.join(' → ')} | ${rootError}`
-    }
-
-    // Single workflow failure
-    return `"${childWorkflowName}" failed: ${rootError}`
-  }
-
-  /**
-   * Parses a potentially nested workflow error message to extract:
-   * - The chain of workflow names
-   * - The actual root error message (preserving the block prefix for the failing block)
-   *
-   * Handles formats like:
-   * - "workflow-name" failed: error
-   * - [block_type] Block Name: "workflow-name" failed: error
-   * - Workflow chain: A → B | error
-   */
-  private parseNestedWorkflowError(message: string): { chain: string[]; rootError: string } {
-    const chain: string[] = []
-    const remaining = message
-
-    // First, check if it's already in chain format
-    const chainMatch = remaining.match(/^Workflow chain: (.+?) \| (.+)$/)
-    if (chainMatch) {
-      const chainPart = chainMatch[1]
-      const errorPart = chainMatch[2]
-      chain.push(...chainPart.split(' → ').map((s) => s.trim()))
-      return { chain, rootError: errorPart }
-    }
-
-    // Extract workflow names from patterns like:
-    // - "workflow-name" failed:
-    // - [block_type] Block Name: "workflow-name" failed:
-    const workflowPattern = /(?:\[[^\]]+\]\s*[^:]+:\s*)?"([^"]+)"\s*failed:\s*/g
-    let match: RegExpExecArray | null
-    let lastIndex = 0
-
-    match = workflowPattern.exec(remaining)
-    while (match !== null) {
-      chain.push(match[1])
-      lastIndex = match.index + match[0].length
-      match = workflowPattern.exec(remaining)
-    }
-
-    // The root error is everything after the last match
-    // Keep the block prefix (e.g., [function] Function 1:) so we know which block failed
-    const rootError = lastIndex > 0 ? remaining.slice(lastIndex) : remaining
-
-    return { chain, rootError: rootError.trim() || 'Unknown error' }
-  }
-
   private async loadChildWorkflow(workflowId: string) {
     const headers = await buildAuthHeaders()
     const url = buildAPIUrl(`/api/workflows/${workflowId}`)
@@ -512,7 +444,7 @@ export class WorkflowBlockHandler implements BlockHandler {
     if (!success) {
       logger.warn(`Child workflow ${childWorkflowName} failed`)
       throw new ChildWorkflowError({
-        message: `"${childWorkflowName}" failed: ${childResult.error || 'Child workflow execution failed'}`,
+        message: `Error in child workflow "${childWorkflowName}": ${childResult.error || 'Child workflow execution failed'}`,
         childWorkflowName,
         childTraceSpans: childTraceSpans || [],
       })

apps/sim/executor/orchestrators/loop.ts

@@ -276,16 +276,7 @@ export class LoopOrchestrator {
     scope: LoopScope
   ): LoopContinuationResult {
     const results = scope.allIterationOutputs
-    const output = { results }
-    this.state.setBlockOutput(loopId, output, DEFAULTS.EXECUTION_TIME)
-
-    // Emit onBlockComplete for the loop container so the UI can track it
-    if (this.contextExtensions?.onBlockComplete) {
-      this.contextExtensions.onBlockComplete(loopId, 'Loop', 'loop', {
-        output,
-        executionTime: DEFAULTS.EXECUTION_TIME,
-      })
-    }
+    this.state.setBlockOutput(loopId, { results }, DEFAULTS.EXECUTION_TIME)
 
     return {
       shouldContinue: false,

apps/sim/executor/orchestrators/node.ts

@@ -31,18 +31,7 @@ export class NodeExecutionOrchestrator {
       throw new Error(`Node not found in DAG: ${nodeId}`)
     }
 
-    if (ctx.runFromBlockContext && !ctx.runFromBlockContext.dirtySet.has(nodeId)) {
-      const cachedOutput = this.state.getBlockOutput(nodeId) || {}
-      logger.debug('Skipping non-dirty block in run-from-block mode', { nodeId })
-      return {
-        nodeId,
-        output: cachedOutput,
-        isFinalOutput: false,
-      }
-    }
-
-    const isDirtyBlock = ctx.runFromBlockContext?.dirtySet.has(nodeId) ?? false
-    if (!isDirtyBlock && this.state.hasExecuted(nodeId)) {
+    if (this.state.hasExecuted(nodeId)) {
       const output = this.state.getBlockOutput(nodeId) || {}
       return {
         nodeId,

apps/sim/executor/orchestrators/parallel.ts

@@ -260,17 +260,9 @@ export class ParallelOrchestrator {
       const branchOutputs = scope.branchOutputs.get(i) || []
       results.push(branchOutputs)
     }
-    const output = { results }
-    this.state.setBlockOutput(parallelId, output)
-
-    // Emit onBlockComplete for the parallel container so the UI can track it
-    if (this.contextExtensions?.onBlockComplete) {
-      this.contextExtensions.onBlockComplete(parallelId, 'Parallel', 'parallel', {
-        output,
-        executionTime: 0,
-      })
-    }
-
+    this.state.setBlockOutput(parallelId, {
+      results,
+    })
     return {
       allBranchesComplete: true,
       results,

apps/sim/executor/types.ts

@@ -1,7 +1,6 @@
 import type { TraceSpan } from '@/lib/logs/types'
 import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
 import type { BlockOutput } from '@/blocks/types'
-import type { RunFromBlockContext } from '@/executor/utils/run-from-block'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 
 export interface UserFile {
@@ -114,12 +113,6 @@ export interface BlockLog {
   loopId?: string
   parallelId?: string
   iterationIndex?: number
-  /**
-   * Child workflow trace spans for nested workflow execution.
-   * Stored separately from output to keep output clean for display
-   * while preserving data for trace-spans processing.
-   */
-  childTraceSpans?: TraceSpan[]
 }
 
 export interface ExecutionMetadata {
@@ -257,17 +250,6 @@ export interface ExecutionContext {
    * will not have their base64 content fetched.
    */
   base64MaxBytes?: number
-
-  /**
-   * Context for "run from block" mode. When present, only blocks in dirtySet
-   * will be executed; others return cached outputs from the source snapshot.
-   */
-  runFromBlockContext?: RunFromBlockContext
-
-  /**
-   * Stop execution after this block completes. Used for "run until block" feature.
-   */
-  stopAfterBlockId?: string
 }
 
 export interface ExecutionResult {

apps/sim/executor/utils/output-filter.ts

@@ -1,4 +1,3 @@
-import { filterHiddenOutputKeys } from '@/lib/logs/execution/trace-spans/trace-spans'
 import { getBlock } from '@/blocks'
 import { isHiddenFromDisplay } from '@/blocks/types'
 import { isTriggerBehavior, isTriggerInternalKey } from '@/executor/constants'
@@ -8,7 +7,6 @@ import type { SerializedBlock } from '@/serializer/types'
 /**
  * Filters block output for logging/display purposes.
  * Removes internal fields and fields marked with hiddenFromDisplay.
- * Also recursively filters globally hidden keys from nested objects.
  *
  * @param blockType - The block type string (e.g., 'human_in_the_loop', 'workflow')
  * @param output - The raw block output to filter
@@ -46,8 +44,7 @@ export function filterOutputForLog(
       continue
     }
 
-    // Recursively filter globally hidden keys from nested objects
-    filtered[key] = filterHiddenOutputKeys(value)
+    filtered[key] = value
   }
 
   return filtered

apps/sim/executor/utils/run-from-block.ts

@@ -1,219 +0,0 @@
-import { LOOP, PARALLEL } from '@/executor/constants'
-import type { DAG } from '@/executor/dag/builder'
-
-/**
- * Builds the sentinel-start node ID for a loop.
- */
-function buildLoopSentinelStartId(loopId: string): string {
-  return `${LOOP.SENTINEL.PREFIX}${loopId}${LOOP.SENTINEL.START_SUFFIX}`
-}
-
-/**
- * Builds the sentinel-start node ID for a parallel.
- */
-function buildParallelSentinelStartId(parallelId: string): string {
-  return `${PARALLEL.SENTINEL.PREFIX}${parallelId}${PARALLEL.SENTINEL.START_SUFFIX}`
-}
-
-/**
- * Checks if a block ID is a loop or parallel container and returns the sentinel-start ID if so.
- * Returns null if the block is not a container.
- */
-export function resolveContainerToSentinelStart(blockId: string, dag: DAG): string | null {
-  if (dag.loopConfigs.has(blockId)) {
-    return buildLoopSentinelStartId(blockId)
-  }
-  if (dag.parallelConfigs.has(blockId)) {
-    return buildParallelSentinelStartId(blockId)
-  }
-  return null
-}
-
-/**
- * Result of validating a block for run-from-block execution.
- */
-export interface RunFromBlockValidation {
-  valid: boolean
-  error?: string
-}
-
-/**
- * Context for run-from-block execution mode.
- */
-export interface RunFromBlockContext {
-  /** The block ID to start execution from */
-  startBlockId: string
-  /** Set of block IDs that need re-execution (start block + all downstream) */
-  dirtySet: Set<string>
-}
-
-/**
- * Result of computing execution sets for run-from-block mode.
- */
-export interface ExecutionSets {
-  /** Blocks that need re-execution (start block + all downstream) */
-  dirtySet: Set<string>
-  /** Blocks that are upstream (ancestors) of the start block */
-  upstreamSet: Set<string>
-  /** Blocks that are upstream of any dirty block (for snapshot preservation) */
-  reachableUpstreamSet: Set<string>
-}
-
-/**
- * Computes the dirty set, upstream set, and reachable upstream set.
- * - Dirty set: start block + all blocks reachable via outgoing edges (need re-execution)
- * - Upstream set: all blocks reachable via incoming edges from the start block
- * - Reachable upstream set: all non-dirty blocks that are upstream of ANY dirty block
- *   (includes sibling branches that dirty blocks may reference)
- *
- * For loop/parallel containers, starts from the sentinel-start node and includes
- * the container ID itself in the dirty set.
- *
- * @param dag - The workflow DAG
- * @param startBlockId - The block to start execution from
- * @returns Object containing dirtySet, upstreamSet, and reachableUpstreamSet
- */
-export function computeExecutionSets(dag: DAG, startBlockId: string): ExecutionSets {
-  const dirty = new Set<string>([startBlockId])
-  const upstream = new Set<string>()
-  const sentinelStartId = resolveContainerToSentinelStart(startBlockId, dag)
-  const traversalStartId = sentinelStartId ?? startBlockId
-
-  if (sentinelStartId) {
-    dirty.add(sentinelStartId)
-  }
-
-  // BFS downstream for dirty set
-  const downstreamQueue = [traversalStartId]
-  while (downstreamQueue.length > 0) {
-    const nodeId = downstreamQueue.shift()!
-    const node = dag.nodes.get(nodeId)
-    if (!node) continue
-
-    for (const [, edge] of node.outgoingEdges) {
-      if (!dirty.has(edge.target)) {
-        dirty.add(edge.target)
-        downstreamQueue.push(edge.target)
-      }
-    }
-  }
-
-  // BFS upstream from start block for upstream set
-  const upstreamQueue = [traversalStartId]
-  while (upstreamQueue.length > 0) {
-    const nodeId = upstreamQueue.shift()!
-    const node = dag.nodes.get(nodeId)
-    if (!node) continue
-
-    for (const sourceId of node.incomingEdges) {
-      if (!upstream.has(sourceId)) {
-        upstream.add(sourceId)
-        upstreamQueue.push(sourceId)
-      }
-    }
-  }
-
-  // Compute reachable upstream: all non-dirty blocks upstream of ANY dirty block
-  // This handles the case where a dirty block (like C in A->C, B->C) may reference
-  // sibling branches (like B when running from A)
-  const reachableUpstream = new Set<string>()
-  for (const dirtyNodeId of dirty) {
-    const node = dag.nodes.get(dirtyNodeId)
-    if (!node) continue
-
-    // BFS upstream from this dirty node
-    const queue = [...node.incomingEdges]
-    while (queue.length > 0) {
-      const sourceId = queue.shift()!
-      if (reachableUpstream.has(sourceId) || dirty.has(sourceId)) continue
-
-      reachableUpstream.add(sourceId)
-      const sourceNode = dag.nodes.get(sourceId)
-      if (sourceNode) {
-        queue.push(...sourceNode.incomingEdges)
-      }
-    }
-  }
-
-  return { dirtySet: dirty, upstreamSet: upstream, reachableUpstreamSet: reachableUpstream }
-}
-
-/**
- * Validates that a block can be used as a run-from-block starting point.
- *
- * Validation rules:
- * - Block must exist in the DAG (or be a loop/parallel container)
- * - Block cannot be inside a loop (but loop containers are allowed)
- * - Block cannot be inside a parallel (but parallel containers are allowed)
- * - Block cannot be a sentinel node
- * - All upstream dependencies must have been executed (have cached outputs)
- *
- * @param blockId - The block ID to validate
- * @param dag - The workflow DAG
- * @param executedBlocks - Set of blocks that were executed in the source run
- * @returns Validation result with error message if invalid
- */
-export function validateRunFromBlock(
-  blockId: string,
-  dag: DAG,
-  executedBlocks: Set<string>
-): RunFromBlockValidation {
-  const node = dag.nodes.get(blockId)
-  const isLoopContainer = dag.loopConfigs.has(blockId)
-  const isParallelContainer = dag.parallelConfigs.has(blockId)
-  const isContainer = isLoopContainer || isParallelContainer
-
-  if (!node && !isContainer) {
-    return { valid: false, error: `Block not found in workflow: ${blockId}` }
-  }
-
-  if (isContainer) {
-    const sentinelStartId = resolveContainerToSentinelStart(blockId, dag)
-    if (!sentinelStartId || !dag.nodes.has(sentinelStartId)) {
-      return {
-        valid: false,
-        error: `Container sentinel not found for: ${blockId}`,
-      }
-    }
-  }
-
-  if (node) {
-    if (node.metadata.isLoopNode) {
-      return {
-        valid: false,
-        error: `Cannot run from block inside loop: ${node.metadata.loopId}`,
-      }
-    }
-
-    if (node.metadata.isParallelBranch) {
-      return {
-        valid: false,
-        error: `Cannot run from block inside parallel: ${node.metadata.parallelId}`,
-      }
-    }
-
-    if (node.metadata.isSentinel) {
-      return { valid: false, error: 'Cannot run from sentinel node' }
-    }
-
-    // Check immediate upstream dependencies were executed
-    for (const sourceId of node.incomingEdges) {
-      const sourceNode = dag.nodes.get(sourceId)
-      // Skip sentinel nodes - they're internal and not in executedBlocks
-      if (sourceNode?.metadata.isSentinel) continue
-
-      // Skip trigger nodes - they're entry points and don't need prior execution
-      // A trigger node has no incoming edges
-      if (sourceNode && sourceNode.incomingEdges.size === 0) continue
-
-      if (!executedBlocks.has(sourceId)) {
-        return {
-          valid: false,
-          error: `Upstream dependency not executed: ${sourceId}`,
-        }
-      }
-    }
-  }
-
-  return { valid: true }
-}

apps/sim/hooks/queries/deployments.ts

@@ -2,7 +2,6 @@ import { createLogger } from '@sim/logger'
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import type { WorkflowDeploymentVersionResponse } from '@/lib/workflows/persistence/utils'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
-import { fetchDeploymentVersionState } from './workflows'
 
 const logger = createLogger('DeploymentQueries')
 
@@ -349,173 +348,6 @@ export function useUndeployWorkflow() {
   })
 }
 
-/**
- * Variables for update deployment version mutation
- */
-interface UpdateDeploymentVersionVariables {
-  workflowId: string
-  version: number
-  name?: string
-  description?: string | null
-}
-
-/**
- * Response from update deployment version mutation
- */
-interface UpdateDeploymentVersionResult {
-  name: string | null
-  description: string | null
-}
-
-/**
- * Mutation hook for updating a deployment version's name or description.
- * Invalidates versions query on success.
- */
-export function useUpdateDeploymentVersion() {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    mutationFn: async ({
-      workflowId,
-      version,
-      name,
-      description,
-    }: UpdateDeploymentVersionVariables): Promise<UpdateDeploymentVersionResult> => {
-      const response = await fetch(`/api/workflows/${workflowId}/deployments/${version}`, {
-        method: 'PATCH',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ name, description }),
-      })
-
-      if (!response.ok) {
-        const errorData = await response.json()
-        throw new Error(errorData.error || 'Failed to update deployment version')
-      }
-
-      return response.json()
-    },
-    onSuccess: (_, variables) => {
-      logger.info('Deployment version updated', {
-        workflowId: variables.workflowId,
-        version: variables.version,
-      })
-
-      queryClient.invalidateQueries({
-        queryKey: deploymentKeys.versions(variables.workflowId),
-      })
-    },
-    onError: (error) => {
-      logger.error('Failed to update deployment version', { error })
-    },
-  })
-}
-
-/**
- * Variables for generating a version description
- */
-interface GenerateVersionDescriptionVariables {
-  workflowId: string
-  version: number
-  onStreamChunk?: (accumulated: string) => void
-}
-
-const VERSION_DESCRIPTION_SYSTEM_PROMPT = `You are a technical writer generating concise deployment version descriptions.
-
-Given a diff of changes between two workflow versions, write a brief, factual description (1-2 sentences, under 300 characters) that states ONLY what changed.
-
-RULES:
-- State specific values when provided (e.g. "model changed from X to Y")
-- Do NOT wrap your response in quotes
-- Do NOT add filler phrases like "streamlining the workflow", "for improved efficiency"
-- Do NOT use markdown formatting
-- Do NOT include version numbers
-- Do NOT start with "This version" or similar phrases
-
-Good examples:
-- Changes model in Agent 1 from gpt-4o to claude-sonnet-4-20250514.
-- Adds Slack notification block. Updates webhook URL to production endpoint.
-- Removes Function block and its connection to Router.
-
-Bad examples:
-- "Changes model..." (NO - don't wrap in quotes)
-- Changes model, streamlining the workflow. (NO - don't add filler)
-
-Respond with ONLY the plain text description.`
-
-/**
- * Hook for generating a version description using AI based on workflow diff
- */
-export function useGenerateVersionDescription() {
-  return useMutation({
-    mutationFn: async ({
-      workflowId,
-      version,
-      onStreamChunk,
-    }: GenerateVersionDescriptionVariables): Promise<string> => {
-      const { generateWorkflowDiffSummary, formatDiffSummaryForDescription } = await import(
-        '@/lib/workflows/comparison/compare'
-      )
-
-      const currentState = await fetchDeploymentVersionState(workflowId, version)
-
-      let previousState = null
-      if (version > 1) {
-        try {
-          previousState = await fetchDeploymentVersionState(workflowId, version - 1)
-        } catch {
-          // Previous version may not exist, continue without it
-        }
-      }
-
-      const diffSummary = generateWorkflowDiffSummary(currentState, previousState)
-      const diffText = formatDiffSummaryForDescription(diffSummary)
-
-      const wandResponse = await fetch('/api/wand', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Cache-Control': 'no-cache, no-transform',
-        },
-        body: JSON.stringify({
-          prompt: `Generate a deployment version description based on these changes:\n\n${diffText}`,
-          systemPrompt: VERSION_DESCRIPTION_SYSTEM_PROMPT,
-          stream: true,
-          workflowId,
-        }),
-        cache: 'no-store',
-      })
-
-      if (!wandResponse.ok) {
-        const errorText = await wandResponse.text()
-        throw new Error(errorText || 'Failed to generate description')
-      }
-
-      if (!wandResponse.body) {
-        throw new Error('Response body is null')
-      }
-
-      const { readSSEStream } = await import('@/lib/core/utils/sse')
-      const accumulatedContent = await readSSEStream(wandResponse.body, {
-        onAccumulated: onStreamChunk,
-      })
-
-      if (!accumulatedContent) {
-        throw new Error('Failed to generate description')
-      }
-
-      return accumulatedContent.trim()
-    },
-    onSuccess: (content) => {
-      logger.info('Generated version description', { length: content.length })
-    },
-    onError: (error) => {
-      logger.error('Failed to generate version description', { error })
-    },
-  })
-}
-
 /**
  * Variables for activate version mutation
  */

apps/sim/hooks/queries/workflows.ts

@@ -411,11 +411,7 @@ interface DeploymentVersionStateResponse {
   deployedState: WorkflowState
 }
 
-/**
- * Fetches the deployed state for a specific deployment version.
- * Exported for reuse in other query hooks.
- */
-export async function fetchDeploymentVersionState(
+async function fetchDeploymentVersionState(
   workflowId: string,
   version: number
 ): Promise<WorkflowState> {

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

@@ -1,85 +1,10 @@
 import { useCallback, useRef } from 'react'
 import { createLogger } from '@sim/logger'
 import type { ExecutionEvent } from '@/lib/workflows/executor/execution-events'
-import type { SerializableExecutionState } from '@/executor/execution/types'
 import type { SubflowType } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('useExecutionStream')
 
-/**
- * Processes SSE events from a response body and invokes appropriate callbacks.
- */
-async function processSSEStream(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-  callbacks: ExecutionStreamCallbacks,
-  logPrefix: string
-): Promise<void> {
-  const decoder = new TextDecoder()
-  let buffer = ''
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-
-      if (done) break
-
-      buffer += decoder.decode(value, { stream: true })
-      const lines = buffer.split('\n\n')
-      buffer = lines.pop() || ''
-
-      for (const line of lines) {
-        if (!line.trim() || !line.startsWith('data: ')) continue
-
-        const data = line.substring(6).trim()
-        if (data === '[DONE]') {
-          logger.info(`${logPrefix} stream completed`)
-          continue
-        }
-
-        try {
-          const event = JSON.parse(data) as ExecutionEvent
-
-          switch (event.type) {
-            case 'execution:started':
-              callbacks.onExecutionStarted?.(event.data)
-              break
-            case 'execution:completed':
-              callbacks.onExecutionCompleted?.(event.data)
-              break
-            case 'execution:error':
-              callbacks.onExecutionError?.(event.data)
-              break
-            case 'execution:cancelled':
-              callbacks.onExecutionCancelled?.(event.data)
-              break
-            case 'block:started':
-              callbacks.onBlockStarted?.(event.data)
-              break
-            case 'block:completed':
-              callbacks.onBlockCompleted?.(event.data)
-              break
-            case 'block:error':
-              callbacks.onBlockError?.(event.data)
-              break
-            case 'stream:chunk':
-              callbacks.onStreamChunk?.(event.data)
-              break
-            case 'stream:done':
-              callbacks.onStreamDone?.(event.data)
-              break
-            default:
-              logger.warn('Unknown event type:', (event as any).type)
-          }
-        } catch (error) {
-          logger.error('Failed to parse SSE event:', error, { data })
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
 export interface ExecutionStreamCallbacks {
   onExecutionStarted?: (data: { startTime: string }) => void
   onExecutionCompleted?: (data: {
@@ -143,15 +68,6 @@ export interface ExecuteStreamOptions {
     loops?: Record<string, any>
     parallels?: Record<string, any>
   }
-  stopAfterBlockId?: string
-  callbacks?: ExecutionStreamCallbacks
-}
-
-export interface ExecuteFromBlockOptions {
-  workflowId: string
-  startBlockId: string
-  sourceSnapshot: SerializableExecutionState
-  input?: any
   callbacks?: ExecutionStreamCallbacks
 }
 
@@ -203,7 +119,91 @@ export function useExecutionStream() {
       }
 
       const reader = response.body.getReader()
-      await processSSEStream(reader, callbacks, 'Execution')
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+
+          if (done) {
+            break
+          }
+
+          buffer += decoder.decode(value, { stream: true })
+
+          const lines = buffer.split('\n\n')
+
+          buffer = lines.pop() || ''
+
+          for (const line of lines) {
+            if (!line.trim() || !line.startsWith('data: ')) {
+              continue
+            }
+
+            const data = line.substring(6).trim()
+
+            if (data === '[DONE]') {
+              logger.info('Stream completed')
+              continue
+            }
+
+            try {
+              const event = JSON.parse(data) as ExecutionEvent
+
+              logger.info('📡 SSE Event received:', {
+                type: event.type,
+                executionId: event.executionId,
+                data: event.data,
+              })
+
+              switch (event.type) {
+                case 'execution:started':
+                  logger.info('🚀 Execution started')
+                  callbacks.onExecutionStarted?.(event.data)
+                  break
+                case 'execution:completed':
+                  logger.info('✅ Execution completed')
+                  callbacks.onExecutionCompleted?.(event.data)
+                  break
+                case 'execution:error':
+                  logger.error('❌ Execution error')
+                  callbacks.onExecutionError?.(event.data)
+                  break
+                case 'execution:cancelled':
+                  logger.warn('🛑 Execution cancelled')
+                  callbacks.onExecutionCancelled?.(event.data)
+                  break
+                case 'block:started':
+                  logger.info('🔷 Block started:', event.data.blockId)
+                  callbacks.onBlockStarted?.(event.data)
+                  break
+                case 'block:completed':
+                  logger.info('✓ Block completed:', event.data.blockId)
+                  callbacks.onBlockCompleted?.(event.data)
+                  break
+                case 'block:error':
+                  logger.error('✗ Block error:', event.data.blockId)
+                  callbacks.onBlockError?.(event.data)
+                  break
+                case 'stream:chunk':
+                  callbacks.onStreamChunk?.(event.data)
+                  break
+                case 'stream:done':
+                  logger.info('Stream done:', event.data.blockId)
+                  callbacks.onStreamDone?.(event.data)
+                  break
+                default:
+                  logger.warn('Unknown event type:', (event as any).type)
+              }
+            } catch (error) {
+              logger.error('Failed to parse SSE event:', error, { data })
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock()
+      }
     } catch (error: any) {
       if (error.name === 'AbortError') {
         logger.info('Execution stream cancelled')
@@ -222,70 +222,6 @@ export function useExecutionStream() {
     }
   }, [])
 
-  const executeFromBlock = useCallback(async (options: ExecuteFromBlockOptions) => {
-    const { workflowId, startBlockId, sourceSnapshot, input, callbacks = {} } = options
-
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort()
-    }
-
-    const abortController = new AbortController()
-    abortControllerRef.current = abortController
-    currentExecutionRef.current = null
-
-    try {
-      const response = await fetch(`/api/workflows/${workflowId}/execute-from-block`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ startBlockId, sourceSnapshot, input }),
-        signal: abortController.signal,
-      })
-
-      if (!response.ok) {
-        let errorResponse: any
-        try {
-          errorResponse = await response.json()
-        } catch {
-          throw new Error(`Server error (${response.status}): ${response.statusText}`)
-        }
-        const error = new Error(errorResponse.error || 'Failed to start execution')
-        if (errorResponse && typeof errorResponse === 'object') {
-          Object.assign(error, { executionResult: errorResponse })
-        }
-        throw error
-      }
-
-      if (!response.body) {
-        throw new Error('No response body')
-      }
-
-      const executionId = response.headers.get('X-Execution-Id')
-      if (executionId) {
-        currentExecutionRef.current = { workflowId, executionId }
-      }
-
-      const reader = response.body.getReader()
-      await processSSEStream(reader, callbacks, 'Run-from-block')
-    } catch (error: any) {
-      if (error.name === 'AbortError') {
-        logger.info('Run-from-block execution cancelled')
-        callbacks.onExecutionCancelled?.({ duration: 0 })
-      } else {
-        logger.error('Run-from-block execution error:', error)
-        callbacks.onExecutionError?.({
-          error: error.message || 'Unknown error',
-          duration: 0,
-        })
-      }
-      throw error
-    } finally {
-      abortControllerRef.current = null
-      currentExecutionRef.current = null
-    }
-  }, [])
-
   const cancel = useCallback(() => {
     const execution = currentExecutionRef.current
     if (execution) {
@@ -303,7 +239,6 @@ export function useExecutionStream() {
 
   return {
     execute,
-    executeFromBlock,
     cancel,
   }
 }

apps/sim/lib/auth/auth.ts

@@ -452,7 +452,6 @@ export const auth = betterAuth({
         'linear',
         'shopify',
         'trello',
-        'calcom',
         ...SSO_TRUSTED_PROVIDERS,
       ],
     },
@@ -2542,55 +2541,6 @@ export const auth = betterAuth({
             }
           },
         },
-
-        // Cal.com provider
-        {
-          providerId: 'calcom',
-          clientId: env.CALCOM_CLIENT_ID as string,
-          authorizationUrl: 'https://app.cal.com/auth/oauth2/authorize',
-          tokenUrl: 'https://app.cal.com/api/auth/oauth/token',
-          scopes: [],
-          responseType: 'code',
-          pkce: true,
-          accessType: 'offline',
-          prompt: 'consent',
-          redirectURI: `${getBaseUrl()}/api/auth/oauth2/callback/calcom`,
-          getUserInfo: async (tokens) => {
-            try {
-              logger.info('Fetching Cal.com user profile')
-
-              const response = await fetch('https://api.cal.com/v2/me', {
-                headers: {
-                  Authorization: `Bearer ${tokens.accessToken}`,
-                  'cal-api-version': '2024-08-13',
-                },
-              })
-
-              if (!response.ok) {
-                logger.error('Failed to fetch Cal.com user info', {
-                  status: response.status,
-                  statusText: response.statusText,
-                })
-                throw new Error('Failed to fetch user info')
-              }
-
-              const data = await response.json()
-              const profile = data.data || data
-
-              return {
-                id: `${profile.id?.toString()}-${crypto.randomUUID()}`,
-                name: profile.name || 'Cal.com User',
-                email: profile.email || `${profile.id}@cal.com`,
-                emailVerified: true,
-                createdAt: new Date(),
-                updatedAt: new Date(),
-              }
-            } catch (error) {
-              logger.error('Error in Cal.com getUserInfo:', { error })
-              return null
-            }
-          },
-        },
       ],
     }),
     // Include SSO plugin when enabled

apps/sim/lib/copilot/server-executed-tools.ts

@@ -0,0 +1,162 @@
+/**
+ * Client-side utilities for server-executed tools.
+ *
+ * This module helps the client know which tools are executed server-side
+ * to avoid double-execution.
+ */
+
+import { createLogger } from '@sim/logger'
+
+const logger = createLogger('ServerExecutedTools')
+
+/**
+ * List of tools that are executed server-side.
+ * This is cached after the first fetch.
+ */
+let cachedServerExecutedTools: Set<string> | null = null
+
+/**
+ * Tools currently being executed server-side.
+ * Maps toolCallId to tool info.
+ */
+const serverHandledToolCalls = new Map<
+  string,
+  {
+    toolName: string
+    startedAt: number
+  }
+>()
+
+/**
+ * Fetch the list of server-executed tools from the API.
+ * Results are cached for the session.
+ */
+export async function fetchServerExecutedTools(): Promise<Set<string>> {
+  if (cachedServerExecutedTools) {
+    return cachedServerExecutedTools
+  }
+
+  try {
+    const response = await fetch('/api/copilot/tools/server-executed')
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`)
+    }
+
+    const data = (await response.json()) as { tools: string[] }
+    cachedServerExecutedTools = new Set(data.tools)
+
+    logger.info('Fetched server-executed tools', {
+      count: cachedServerExecutedTools.size,
+      tools: Array.from(cachedServerExecutedTools),
+    })
+
+    return cachedServerExecutedTools
+  } catch (error) {
+    logger.warn('Failed to fetch server-executed tools, using empty set', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    // Return empty set on error - tools will execute client-side as fallback
+    return new Set()
+  }
+}
+
+/**
+ * Check if a tool is executed server-side.
+ * Uses cached list or fetches if not available.
+ */
+export async function isServerExecutedTool(toolName: string): Promise<boolean> {
+  const serverTools = await fetchServerExecutedTools()
+  return serverTools.has(toolName)
+}
+
+/**
+ * Synchronous check if a tool is server-executed.
+ * Returns false if cache is not yet populated.
+ */
+export function isServerExecutedToolSync(toolName: string): boolean {
+  if (!cachedServerExecutedTools) {
+    return false
+  }
+  return cachedServerExecutedTools.has(toolName)
+}
+
+/**
+ * Get the cached list of server-executed tools.
+ * Returns null if not yet fetched.
+ */
+export function getServerExecutedToolsSync(): Set<string> | null {
+  return cachedServerExecutedTools
+}
+
+/**
+ * Mark a tool call as being handled by the server.
+ * Used to prevent client from executing it.
+ */
+export function markToolCallServerHandled(toolCallId: string, toolName: string): void {
+  serverHandledToolCalls.set(toolCallId, {
+    toolName,
+    startedAt: Date.now(),
+  })
+
+  logger.debug('Marked tool call as server-handled', { toolCallId, toolName })
+
+  // Cleanup old entries (older than 1 hour)
+  const oneHourAgo = Date.now() - 60 * 60 * 1000
+  for (const [id, info] of serverHandledToolCalls.entries()) {
+    if (info.startedAt < oneHourAgo) {
+      serverHandledToolCalls.delete(id)
+    }
+  }
+}
+
+/**
+ * Check if a specific tool call is being handled by the server.
+ */
+export function isToolCallServerHandled(toolCallId: string): boolean {
+  return serverHandledToolCalls.has(toolCallId)
+}
+
+/**
+ * Remove a tool call from server-handled tracking.
+ * Called when tool_result is received.
+ */
+export function clearToolCallServerHandled(toolCallId: string): void {
+  serverHandledToolCalls.delete(toolCallId)
+}
+
+/**
+ * Get tool execution state from the server (for reconnection scenarios).
+ */
+export async function getToolExecutionState(toolCallId: string): Promise<{
+  status: 'pending' | 'executing' | 'completed' | 'failed' | 'unknown'
+  result?: unknown
+  error?: string
+} | null> {
+  try {
+    const response = await fetch(`/api/copilot/tools/execution-state/${toolCallId}`)
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null
+      }
+      throw new Error(`HTTP ${response.status}`)
+    }
+
+    return await response.json()
+  } catch (error) {
+    logger.warn('Failed to get tool execution state', {
+      toolCallId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return null
+  }
+}
+
+/**
+ * Pre-fetch server-executed tools list.
+ * Call this early in the app lifecycle.
+ */
+export function prefetchServerExecutedTools(): void {
+  fetchServerExecutedTools().catch(() => {
+    // Errors already logged in fetchServerExecutedTools
+  })
+}

apps/sim/lib/copilot/server-executor/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Server-side tool executor.
+ *
+ * This module provides the ability to execute tools server-side (in Next.js API routes)
+ * rather than requiring the browser to execute them.
+ *
+ * Key function: executeToolOnServer()
+ * - Returns ToolResult if the tool was executed server-side
+ * - Returns null if the tool is not registered (client should handle)
+ */
+
+import { createLogger } from '@sim/logger'
+import { executeRegisteredTool, isServerExecutedTool } from './registry'
+import type { ExecutionContext, ToolResult } from './types'
+
+const logger = createLogger('ServerExecutor')
+
+/**
+ * Execute a tool on the server if it's registered.
+ *
+ * @param toolName - The name of the tool to execute
+ * @param args - The arguments to pass to the tool
+ * @param context - Execution context (userId, workflowId, etc.)
+ * @returns ToolResult if executed, null if tool not registered server-side
+ */
+export async function executeToolOnServer(
+  toolName: string,
+  args: unknown,
+  context: ExecutionContext
+): Promise<ToolResult | null> {
+  // Check if this tool should be executed server-side
+  if (!isServerExecutedTool(toolName)) {
+    logger.debug('Tool not registered for server execution, client will handle', { toolName })
+    return null
+  }
+
+  logger.info('Executing tool server-side', {
+    toolName,
+    userId: context.userId,
+    workflowId: context.workflowId,
+  })
+
+  const startTime = Date.now()
+  const result = await executeRegisteredTool(toolName, args, context)
+
+  logger.info('Tool execution completed', {
+    toolName,
+    success: result.success,
+    durationMs: Date.now() - startTime,
+  })
+
+  return result
+}
+
+export { isServerExecutedTool, SERVER_EXECUTED_TOOLS } from './registry'
+// Re-export types and utilities
+export type { ExecutionContext, ToolResult } from './types'
+export { errorResult, successResult } from './types'

apps/sim/lib/copilot/server-executor/registry.ts

@@ -0,0 +1,461 @@
+/**
+ * Server Tool Registry
+ *
+ * Central registry for all server-executed tools. This replaces the scattered
+ * executor files with a single, declarative registry.
+ *
+ * Benefits:
+ * - Single source of truth for tool registration
+ * - Type-safe with Zod schemas
+ * - No duplicate wrapper code
+ * - Easy to add new tools
+ */
+
+import { createLogger } from '@sim/logger'
+import type { z } from 'zod'
+import { getBlockConfigServerTool } from '../tools/server/blocks/get-block-config'
+import { getBlockOptionsServerTool } from '../tools/server/blocks/get-block-options'
+// Import server tool implementations
+import { getBlocksAndToolsServerTool } from '../tools/server/blocks/get-blocks-and-tools'
+import { getBlocksMetadataServerTool } from '../tools/server/blocks/get-blocks-metadata-tool'
+import { getTriggerBlocksServerTool } from '../tools/server/blocks/get-trigger-blocks'
+import { searchDocumentationServerTool } from '../tools/server/docs/search-documentation'
+import { knowledgeBaseServerTool } from '../tools/server/knowledge/knowledge-base'
+import { CheckoffTodoInput, checkoffTodoServerTool } from '../tools/server/other/checkoff-todo'
+import { makeApiRequestServerTool } from '../tools/server/other/make-api-request'
+import {
+  MarkTodoInProgressInput,
+  markTodoInProgressServerTool,
+} from '../tools/server/other/mark-todo-in-progress'
+import { searchOnlineServerTool } from '../tools/server/other/search-online'
+import { SleepInput, sleepServerTool } from '../tools/server/other/sleep'
+import { setContextServerTool } from '../tools/server/context/set-context'
+import { getCredentialsServerTool } from '../tools/server/user/get-credentials'
+import { setEnvironmentVariablesServerTool } from '../tools/server/user/set-environment-variables'
+import {
+  CheckDeploymentStatusInput,
+  checkDeploymentStatusServerTool,
+} from '../tools/server/workflow/check-deployment-status'
+import {
+  CreateWorkspaceMcpServerInput,
+  createWorkspaceMcpServerServerTool,
+} from '../tools/server/workflow/create-workspace-mcp-server'
+import { DeployApiInput, deployApiServerTool } from '../tools/server/workflow/deploy-api'
+import { DeployChatInput, deployChatServerTool } from '../tools/server/workflow/deploy-chat'
+import { DeployMcpInput, deployMcpServerTool } from '../tools/server/workflow/deploy-mcp'
+import { editWorkflowServerTool } from '../tools/server/workflow/edit-workflow'
+import {
+  GetBlockOutputsInput,
+  getBlockOutputsServerTool,
+} from '../tools/server/workflow/get-block-outputs'
+import {
+  GetUserWorkflowInput,
+  getUserWorkflowServerTool,
+} from '../tools/server/workflow/get-user-workflow'
+import { getWorkflowConsoleServerTool } from '../tools/server/workflow/get-workflow-console'
+import {
+  GetWorkflowFromNameInput,
+  getWorkflowFromNameServerTool,
+} from '../tools/server/workflow/get-workflow-from-name'
+import { listUserWorkflowsServerTool } from '../tools/server/workflow/list-user-workflows'
+import {
+  ListWorkspaceMcpServersInput,
+  listWorkspaceMcpServersServerTool,
+} from '../tools/server/workflow/list-workspace-mcp-servers'
+import { RedeployInput, redeployServerTool } from '../tools/server/workflow/redeploy'
+import { RunWorkflowInput, runWorkflowServerTool } from '../tools/server/workflow/run-workflow'
+import {
+  SetGlobalWorkflowVariablesInput,
+  setGlobalWorkflowVariablesServerTool,
+} from '../tools/server/workflow/set-global-workflow-variables'
+import {
+  GetBlockUpstreamReferencesInput,
+  getBlockUpstreamReferencesServerTool,
+} from '../tools/server/workflow/get-block-upstream-references'
+import {
+  GetWorkflowDataInput,
+  getWorkflowDataServerTool,
+} from '../tools/server/workflow/get-workflow-data'
+import {
+  ManageCustomToolInput,
+  manageCustomToolServerTool,
+} from '../tools/server/workflow/manage-custom-tool'
+import {
+  ManageMcpToolInput,
+  manageMcpToolServerTool,
+} from '../tools/server/workflow/manage-mcp-tool'
+// Import schemas
+import {
+  EditWorkflowInput,
+  GetBlockConfigInput,
+  GetBlockOptionsInput,
+  GetBlocksAndToolsInput,
+  GetBlocksMetadataInput,
+  GetCredentialsInput,
+  GetTriggerBlocksInput,
+  GetWorkflowConsoleInput,
+  KnowledgeBaseArgsSchema,
+  ListUserWorkflowsInput,
+  MakeApiRequestInput,
+  SearchDocumentationInput,
+  SearchOnlineInput,
+  SetContextInput,
+  SetEnvironmentVariablesInput,
+} from '../tools/shared/schemas'
+import type { ExecutionContext, ToolResult } from './types'
+import { errorResult, successResult } from './types'
+
+const logger = createLogger('ToolRegistry')
+
+/**
+ * Context type for server tools.
+ * This is the full execution context passed to tools that need workflow/workspace info.
+ */
+type ServerToolContext =
+  | {
+      userId: string
+      workflowId?: string
+      workspaceId?: string
+    }
+  | undefined
+
+/**
+ * Helper to create a typed executor wrapper.
+ * This provides a clean boundary between our registry (unknown args)
+ * and the underlying typed server tools.
+ *
+ * The generic TArgs is inferred from the Zod schema, ensuring type safety
+ * at compile time while allowing runtime validation.
+ */
+function createExecutor<TArgs, TResult>(
+  serverTool: { execute: (args: TArgs, ctx?: ServerToolContext) => Promise<TResult> },
+  options: { passContext: boolean } = { passContext: true }
+): (args: unknown, ctx: ServerToolContext) => Promise<unknown> {
+  return (args, ctx) => {
+    // After Zod validation, we know args matches TArgs
+    // This cast is safe because validation happens before execution
+    const typedArgs = args as TArgs
+    return options.passContext ? serverTool.execute(typedArgs, ctx) : serverTool.execute(typedArgs)
+  }
+}
+
+/**
+ * Tool registration entry.
+ */
+interface ToolRegistration {
+  /** Zod schema for input validation (optional) */
+  inputSchema?: z.ZodType
+  /** Whether this tool requires authentication */
+  requiresAuth: boolean
+  /** The underlying execute function */
+  execute: (args: unknown, context: ServerToolContext) => Promise<unknown>
+}
+
+/**
+ * The tool registry - maps tool names to their configurations.
+ *
+ * Each tool is registered with:
+ * - inputSchema: Zod schema for validation (optional)
+ * - requiresAuth: Whether userId is required
+ * - execute: The underlying server tool's execute function
+ */
+const TOOL_REGISTRY: Record<string, ToolRegistration> = {
+  // ─────────────────────────────────────────────────────────────────────────
+  // Block Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  get_blocks_and_tools: {
+    inputSchema: GetBlocksAndToolsInput,
+    requiresAuth: true,
+    execute: createExecutor(getBlocksAndToolsServerTool),
+  },
+  get_block_config: {
+    inputSchema: GetBlockConfigInput,
+    requiresAuth: true,
+    execute: createExecutor(getBlockConfigServerTool),
+  },
+  get_block_options: {
+    inputSchema: GetBlockOptionsInput,
+    requiresAuth: true,
+    execute: createExecutor(getBlockOptionsServerTool),
+  },
+  get_blocks_metadata: {
+    inputSchema: GetBlocksMetadataInput,
+    requiresAuth: true,
+    execute: createExecutor(getBlocksMetadataServerTool),
+  },
+  get_trigger_blocks: {
+    inputSchema: GetTriggerBlocksInput,
+    requiresAuth: true,
+    execute: createExecutor(getTriggerBlocksServerTool),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Workflow Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  edit_workflow: {
+    inputSchema: EditWorkflowInput,
+    requiresAuth: true,
+    execute: createExecutor(editWorkflowServerTool),
+  },
+  get_workflow_console: {
+    inputSchema: GetWorkflowConsoleInput,
+    requiresAuth: false, // Tool validates workflowId itself
+    execute: createExecutor(getWorkflowConsoleServerTool, { passContext: false }),
+  },
+  list_user_workflows: {
+    inputSchema: ListUserWorkflowsInput,
+    requiresAuth: true,
+    execute: createExecutor(listUserWorkflowsServerTool),
+  },
+  get_workflow_from_name: {
+    inputSchema: GetWorkflowFromNameInput,
+    requiresAuth: true,
+    execute: createExecutor(getWorkflowFromNameServerTool),
+  },
+  check_deployment_status: {
+    inputSchema: CheckDeploymentStatusInput,
+    requiresAuth: true,
+    execute: createExecutor(checkDeploymentStatusServerTool),
+  },
+  list_workspace_mcp_servers: {
+    inputSchema: ListWorkspaceMcpServersInput,
+    requiresAuth: true,
+    execute: createExecutor(listWorkspaceMcpServersServerTool),
+  },
+  set_global_workflow_variables: {
+    inputSchema: SetGlobalWorkflowVariablesInput,
+    requiresAuth: true,
+    execute: createExecutor(setGlobalWorkflowVariablesServerTool),
+  },
+  redeploy: {
+    inputSchema: RedeployInput,
+    requiresAuth: true,
+    execute: createExecutor(redeployServerTool),
+  },
+  create_workspace_mcp_server: {
+    inputSchema: CreateWorkspaceMcpServerInput,
+    requiresAuth: true,
+    execute: createExecutor(createWorkspaceMcpServerServerTool),
+  },
+  deploy_api: {
+    inputSchema: DeployApiInput,
+    requiresAuth: true,
+    execute: createExecutor(deployApiServerTool),
+  },
+  deploy_chat: {
+    inputSchema: DeployChatInput,
+    requiresAuth: true,
+    execute: createExecutor(deployChatServerTool),
+  },
+  deploy_mcp: {
+    inputSchema: DeployMcpInput,
+    requiresAuth: true,
+    execute: createExecutor(deployMcpServerTool),
+  },
+  run_workflow: {
+    inputSchema: RunWorkflowInput,
+    requiresAuth: true,
+    execute: createExecutor(runWorkflowServerTool),
+  },
+  get_user_workflow: {
+    inputSchema: GetUserWorkflowInput,
+    requiresAuth: true,
+    execute: createExecutor(getUserWorkflowServerTool),
+  },
+  get_block_outputs: {
+    inputSchema: GetBlockOutputsInput,
+    requiresAuth: true,
+    execute: createExecutor(getBlockOutputsServerTool),
+  },
+  get_block_upstream_references: {
+    inputSchema: GetBlockUpstreamReferencesInput,
+    requiresAuth: true,
+    execute: createExecutor(getBlockUpstreamReferencesServerTool),
+  },
+  get_workflow_data: {
+    inputSchema: GetWorkflowDataInput,
+    requiresAuth: true,
+    execute: createExecutor(getWorkflowDataServerTool),
+  },
+  manage_custom_tool: {
+    inputSchema: ManageCustomToolInput,
+    requiresAuth: true,
+    execute: createExecutor(manageCustomToolServerTool),
+  },
+  manage_mcp_tool: {
+    inputSchema: ManageMcpToolInput,
+    requiresAuth: true,
+    execute: createExecutor(manageMcpToolServerTool),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Search Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  search_documentation: {
+    inputSchema: SearchDocumentationInput,
+    requiresAuth: false,
+    execute: createExecutor(searchDocumentationServerTool, { passContext: false }),
+  },
+  search_online: {
+    inputSchema: SearchOnlineInput,
+    requiresAuth: false,
+    execute: createExecutor(searchOnlineServerTool, { passContext: false }),
+  },
+  make_api_request: {
+    inputSchema: MakeApiRequestInput,
+    requiresAuth: false,
+    execute: createExecutor(makeApiRequestServerTool, { passContext: false }),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Knowledge Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  knowledge_base: {
+    inputSchema: KnowledgeBaseArgsSchema,
+    requiresAuth: true,
+    execute: createExecutor(knowledgeBaseServerTool),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // User Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  get_credentials: {
+    inputSchema: GetCredentialsInput,
+    requiresAuth: true,
+    execute: createExecutor(getCredentialsServerTool),
+  },
+  set_environment_variables: {
+    inputSchema: SetEnvironmentVariablesInput,
+    requiresAuth: true,
+    execute: createExecutor(setEnvironmentVariablesServerTool),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Context Tools (for headless mode)
+  // ─────────────────────────────────────────────────────────────────────────
+  set_context: {
+    inputSchema: SetContextInput,
+    requiresAuth: true,
+    execute: createExecutor(setContextServerTool),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Todo Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  checkoff_todo: {
+    inputSchema: CheckoffTodoInput,
+    requiresAuth: false, // Just returns success, no auth needed
+    execute: createExecutor(checkoffTodoServerTool, { passContext: false }),
+  },
+  mark_todo_in_progress: {
+    inputSchema: MarkTodoInProgressInput,
+    requiresAuth: false,
+    execute: createExecutor(markTodoInProgressServerTool, { passContext: false }),
+  },
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Utility Tools
+  // ─────────────────────────────────────────────────────────────────────────
+  sleep: {
+    inputSchema: SleepInput,
+    requiresAuth: false,
+    execute: createExecutor(sleepServerTool, { passContext: false }),
+  },
+}
+
+/**
+ * Tools that should only be auto-intercepted in headless mode.
+ * In UI mode, the client tool handles these (e.g., to show diff review).
+ */
+const HEADLESS_ONLY_TOOLS = new Set(['edit_workflow'])
+
+/**
+ * List of all server-executed tool names.
+ * Export this so clients know which tools NOT to execute locally.
+ * Note: edit_workflow is excluded because it needs client-side diff review in UI mode.
+ */
+export const SERVER_EXECUTED_TOOLS = Object.keys(TOOL_REGISTRY).filter(
+  (name) => !HEADLESS_ONLY_TOOLS.has(name)
+)
+
+/**
+ * Check if a tool is registered for server execution.
+ * @param toolName - The tool name to check
+ * @param source - Optional execution source. If 'ui', headless-only tools return false.
+ */
+export function isServerExecutedTool(
+  toolName: string,
+  source?: 'ui' | 'headless'
+): boolean {
+  if (!(toolName in TOOL_REGISTRY)) {
+    return false
+  }
+  // In UI mode, headless-only tools are NOT server-executed (client handles them)
+  if (source === 'ui' && HEADLESS_ONLY_TOOLS.has(toolName)) {
+    return false
+  }
+  return true
+}
+
+/**
+ * Execute a tool with proper validation and error handling.
+ *
+ * This is the main entry point for tool execution. It:
+ * 1. Looks up the tool in the registry
+ * 2. Validates input against the schema (if provided)
+ * 3. Checks authentication requirements
+ * 4. Executes the tool
+ * 5. Returns a standardized ToolResult
+ */
+export async function executeRegisteredTool(
+  toolName: string,
+  args: unknown,
+  context: ExecutionContext
+): Promise<ToolResult> {
+  const registration = TOOL_REGISTRY[toolName]
+
+  if (!registration) {
+    logger.warn('Unknown tool requested', { toolName })
+    return errorResult('UNKNOWN_TOOL', `Tool '${toolName}' is not registered for server execution`)
+  }
+
+  // Check authentication requirement
+  if (registration.requiresAuth && !context.userId) {
+    logger.error('Authentication required but not provided', { toolName })
+    return errorResult('AUTH_REQUIRED', `Tool '${toolName}' requires authentication`)
+  }
+
+  // Validate input if schema is provided
+  let validatedArgs: unknown = args ?? {}
+  if (registration.inputSchema) {
+    const parseResult = registration.inputSchema.safeParse(args ?? {})
+    if (!parseResult.success) {
+      logger.warn('Input validation failed', {
+        toolName,
+        errors: parseResult.error.flatten(),
+      })
+      return errorResult('VALIDATION_ERROR', 'Invalid input arguments', {
+        errors: parseResult.error.flatten().fieldErrors,
+      })
+    }
+    validatedArgs = parseResult.data
+  }
+
+  // Execute the tool
+  try {
+    // Pass the full execution context so tools can access workflowId/workspaceId
+    const toolContext = context.userId
+      ? {
+          userId: context.userId,
+          workflowId: context.workflowId,
+          workspaceId: context.workspaceId,
+        }
+      : undefined
+    const result = await registration.execute(validatedArgs, toolContext)
+    return successResult(result)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logger.error('Tool execution failed', { toolName, error: message })
+    return errorResult('EXECUTION_ERROR', message)
+  }
+}

apps/sim/lib/copilot/server-executor/stream-handler.ts

@@ -0,0 +1,434 @@
+/**
+ * SSE Stream Tool Execution Handler
+ *
+ * This module intercepts tool_call events from the Go copilot SSE stream
+ * and executes server-side tools, calling mark-complete to return results.
+ *
+ * Key features:
+ * - Non-blocking: Tool execution happens in parallel with stream forwarding
+ * - Resilient: Uses Redis for state persistence across disconnects
+ * - Transparent: Still forwards all events to browser for UI updates
+ */
+
+import { createLogger } from '@sim/logger'
+import { SIM_AGENT_API_URL_DEFAULT } from '@/lib/copilot/constants'
+import { env } from '@/lib/core/config/env'
+import { getRedisClient } from '@/lib/core/config/redis'
+import { executeToolOnServer, isServerExecutedTool } from './index'
+import type { ExecutionContext } from './types'
+
+const logger = createLogger('StreamToolHandler')
+
+const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
+
+/** Redis key prefix for tool execution state */
+const REDIS_KEY_PREFIX = 'copilot:tool_exec:'
+
+/** TTL for Redis entries (1 hour) */
+const REDIS_TTL_SECONDS = 60 * 60
+
+/**
+ * Tool execution state stored in Redis
+ */
+interface ToolExecutionState {
+  toolCallId: string
+  toolName: string
+  status: 'pending' | 'executing' | 'completed' | 'failed'
+  userId: string
+  workflowId?: string
+  workspaceId?: string
+  chatId?: string
+  startedAt: number
+  completedAt?: number
+  result?: unknown
+  error?: string
+}
+
+/**
+ * Tool call data from SSE event
+ */
+interface ToolCallEvent {
+  id: string
+  name: string
+  arguments: Record<string, unknown>
+  partial?: boolean
+}
+
+/**
+ * Save tool execution state to Redis.
+ */
+async function saveToolState(state: ToolExecutionState): Promise<void> {
+  const redis = getRedisClient()
+  if (!redis) {
+    logger.debug('Redis not available, skipping state save', {
+      toolCallId: state.toolCallId,
+    })
+    return
+  }
+
+  try {
+    const key = `${REDIS_KEY_PREFIX}${state.toolCallId}`
+    await redis.setex(key, REDIS_TTL_SECONDS, JSON.stringify(state))
+    logger.debug('Saved tool execution state to Redis', {
+      toolCallId: state.toolCallId,
+      status: state.status,
+    })
+  } catch (error) {
+    logger.warn('Failed to save tool state to Redis', {
+      toolCallId: state.toolCallId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+/**
+ * Get tool execution state from Redis.
+ */
+async function getToolState(toolCallId: string): Promise<ToolExecutionState | null> {
+  const redis = getRedisClient()
+  if (!redis) return null
+
+  try {
+    const key = `${REDIS_KEY_PREFIX}${toolCallId}`
+    const data = await redis.get(key)
+    if (!data) return null
+    return JSON.parse(data) as ToolExecutionState
+  } catch (error) {
+    logger.warn('Failed to get tool state from Redis', {
+      toolCallId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return null
+  }
+}
+
+/**
+ * Mark a tool as complete by calling the Go copilot endpoint.
+ */
+async function markToolComplete(
+  toolCallId: string,
+  toolName: string,
+  status: number,
+  message?: unknown,
+  data?: unknown
+): Promise<boolean> {
+  try {
+    const payload = {
+      id: toolCallId,
+      name: toolName,
+      status,
+      message,
+      data,
+    }
+
+    logger.info('Marking tool complete from server', {
+      toolCallId,
+      toolName,
+      status,
+      hasMessage: message !== undefined,
+      hasData: data !== undefined,
+    })
+
+    const response = await fetch(`${SIM_AGENT_API_URL}/api/tools/mark-complete`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+      },
+      body: JSON.stringify(payload),
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => '')
+      logger.error('Failed to mark tool complete', {
+        toolCallId,
+        toolName,
+        status: response.status,
+        error: errorText,
+      })
+      return false
+    }
+
+    logger.info('Tool marked complete successfully', { toolCallId, toolName })
+    return true
+  } catch (error) {
+    logger.error('Error marking tool complete', {
+      toolCallId,
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return false
+  }
+}
+
+/**
+ * Handle a tool call event from the SSE stream.
+ *
+ * If the tool is server-executed:
+ * 1. Execute it using the server executor
+ * 2. Call mark-complete to return result to Go
+ *
+ * This runs asynchronously and doesn't block the stream.
+ *
+ * @returns true if this tool will be handled server-side, false if client should handle
+ */
+export async function handleToolCallEvent(
+  event: ToolCallEvent,
+  context: ExecutionContext
+): Promise<boolean> {
+  // Skip partial tool calls (streaming arguments)
+  if (event.partial) {
+    return false
+  }
+
+  // Check if this tool should be executed server-side
+  // Pass source to handle headless-only tools (e.g., edit_workflow in UI mode is client-handled)
+  if (!isServerExecutedTool(event.name, context.source)) {
+    logger.debug('Tool not server-executed, client will handle', {
+      toolCallId: event.id,
+      toolName: event.name,
+      source: context.source,
+    })
+    return false
+  }
+
+  // Check if this tool is already being executed (recovery scenario)
+  const existingState = await getToolState(event.id)
+  if (existingState) {
+    if (existingState.status === 'executing') {
+      logger.info('Tool already being executed (recovery scenario)', {
+        toolCallId: event.id,
+        toolName: event.name,
+        startedAt: existingState.startedAt,
+      })
+      return true
+    }
+    if (existingState.status === 'completed') {
+      logger.info('Tool already completed (recovery scenario)', {
+        toolCallId: event.id,
+        toolName: event.name,
+        completedAt: existingState.completedAt,
+      })
+      return true
+    }
+  }
+
+  logger.info('Handling tool call server-side', {
+    toolCallId: event.id,
+    toolName: event.name,
+    userId: context.userId,
+  })
+
+  // Save initial state to Redis
+  await saveToolState({
+    toolCallId: event.id,
+    toolName: event.name,
+    status: 'pending',
+    userId: context.userId,
+    workflowId: context.workflowId,
+    workspaceId: context.workspaceId,
+    chatId: context.chatId,
+    startedAt: Date.now(),
+  })
+
+  // Execute asynchronously - don't await here to avoid blocking stream
+  executeToolServerSide(event, context).catch((error) => {
+    logger.error('Async tool execution failed', {
+      toolCallId: event.id,
+      toolName: event.name,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  })
+
+  return true
+}
+
+/**
+ * Execute a tool server-side and mark it complete.
+ * This is called asynchronously from handleToolCallEvent.
+ */
+async function executeToolServerSide(
+  event: ToolCallEvent,
+  context: ExecutionContext
+): Promise<void> {
+  const startTime = Date.now()
+
+  // Update state to executing
+  await saveToolState({
+    toolCallId: event.id,
+    toolName: event.name,
+    status: 'executing',
+    userId: context.userId,
+    workflowId: context.workflowId,
+    workspaceId: context.workspaceId,
+    chatId: context.chatId,
+    startedAt: startTime,
+  })
+
+  try {
+    const result = await executeToolOnServer(event.name, event.arguments, context)
+
+    if (!result) {
+      // This shouldn't happen since we checked isServerExecutedTool
+      logger.error('executeToolOnServer returned null for registered tool', {
+        toolCallId: event.id,
+        toolName: event.name,
+      })
+
+      await saveToolState({
+        toolCallId: event.id,
+        toolName: event.name,
+        status: 'failed',
+        userId: context.userId,
+        workflowId: context.workflowId,
+        workspaceId: context.workspaceId,
+        chatId: context.chatId,
+        startedAt: startTime,
+        completedAt: Date.now(),
+        error: 'Internal error: tool not found',
+      })
+
+      await markToolComplete(event.id, event.name, 500, 'Internal error: tool not found')
+      return
+    }
+
+    const durationMs = Date.now() - startTime
+
+    if (result.success) {
+      logger.info('Tool executed successfully', {
+        toolCallId: event.id,
+        toolName: event.name,
+        durationMs,
+      })
+
+      await saveToolState({
+        toolCallId: event.id,
+        toolName: event.name,
+        status: 'completed',
+        userId: context.userId,
+        workflowId: context.workflowId,
+        workspaceId: context.workspaceId,
+        chatId: context.chatId,
+        startedAt: startTime,
+        completedAt: Date.now(),
+        result: result.data,
+      })
+
+      // Mark complete with success
+      await markToolComplete(
+        event.id,
+        event.name,
+        200,
+        undefined, // message
+        result.data // data
+      )
+    } else {
+      logger.warn('Tool execution failed', {
+        toolCallId: event.id,
+        toolName: event.name,
+        durationMs,
+        error: result.error,
+      })
+
+      await saveToolState({
+        toolCallId: event.id,
+        toolName: event.name,
+        status: 'failed',
+        userId: context.userId,
+        workflowId: context.workflowId,
+        workspaceId: context.workspaceId,
+        chatId: context.chatId,
+        startedAt: startTime,
+        completedAt: Date.now(),
+        error: result.error?.message,
+      })
+
+      // Mark complete with error
+      await markToolComplete(
+        event.id,
+        event.name,
+        400,
+        result.error?.message ?? 'Tool execution failed',
+        result.error?.details
+      )
+    }
+  } catch (error) {
+    const durationMs = Date.now() - startTime
+    const message = error instanceof Error ? error.message : String(error)
+
+    logger.error('Tool execution threw exception', {
+      toolCallId: event.id,
+      toolName: event.name,
+      durationMs,
+      error: message,
+    })
+
+    await saveToolState({
+      toolCallId: event.id,
+      toolName: event.name,
+      status: 'failed',
+      userId: context.userId,
+      workflowId: context.workflowId,
+      workspaceId: context.workspaceId,
+      chatId: context.chatId,
+      startedAt: startTime,
+      completedAt: Date.now(),
+      error: message,
+    })
+
+    // Mark complete with error
+    await markToolComplete(event.id, event.name, 500, message)
+  }
+}
+
+/**
+ * In-memory fallback for tracking server-handled tools when Redis is unavailable.
+ */
+const serverHandledTools = new Map<string, { toolName: string; handledAt: number }>()
+
+/**
+ * Register a tool as being handled server-side.
+ */
+export function registerServerHandledTool(toolCallId: string, toolName: string): void {
+  serverHandledTools.set(toolCallId, {
+    toolName,
+    handledAt: Date.now(),
+  })
+
+  // Clean up old entries (older than 1 hour)
+  const oneHourAgo = Date.now() - 60 * 60 * 1000
+  for (const [id, info] of serverHandledTools.entries()) {
+    if (info.handledAt < oneHourAgo) {
+      serverHandledTools.delete(id)
+    }
+  }
+}
+
+/**
+ * Check if a tool was handled server-side.
+ */
+export async function wasToolHandledServerSide(toolCallId: string): Promise<boolean> {
+  // Check in-memory first
+  if (serverHandledTools.has(toolCallId)) {
+    return true
+  }
+
+  // Check Redis
+  const state = await getToolState(toolCallId)
+  return state !== null
+}
+
+/**
+ * Get the execution state of a tool.
+ * Useful for client reconnection scenarios.
+ */
+export async function getToolExecutionState(
+  toolCallId: string
+): Promise<ToolExecutionState | null> {
+  return getToolState(toolCallId)
+}
+
+/**
+ * Get list of server-executed tool names for client reference.
+ */
+export { SERVER_EXECUTED_TOOLS } from './registry'

apps/sim/lib/copilot/server-executor/types.ts

@@ -0,0 +1,99 @@
+/**
+ * Type definitions for the server executor.
+ *
+ * This provides a clean, type-safe interface for tool execution
+ * without any 'any' types.
+ */
+
+import type { z } from 'zod'
+
+/**
+ * Standard result type for all tool executions.
+ * This is the contract between server executors and the chat route.
+ */
+export interface ToolResult<T = unknown> {
+  success: boolean
+  data?: T
+  error?: {
+    code: string
+    message: string
+    details?: Record<string, unknown>
+  }
+}
+
+/**
+ * Execution source - whether the request came from UI or headless API.
+ */
+export type ExecutionSource = 'ui' | 'headless'
+
+/**
+ * Context passed to tool executors.
+ *
+ * This context is passed from Go copilot to SIM on each tool_call event.
+ * In client mode, workflowId/workspaceId come from the initial request.
+ * In headless mode, they can be set dynamically via the set_context tool.
+ */
+export interface ExecutionContext {
+  userId: string
+  workflowId?: string
+  workspaceId?: string
+  chatId?: string
+  /** Whether request came from UI (with diff review) or headless API (direct save) */
+  source?: ExecutionSource
+}
+
+/**
+ * Configuration for a registered tool.
+ * This defines how a tool should be validated and executed.
+ */
+export interface ToolConfig<
+  TInputSchema extends z.ZodType = z.ZodType,
+  TOutputSchema extends z.ZodType = z.ZodType,
+> {
+  /** The canonical name of the tool */
+  name: string
+
+  /** Zod schema for validating input args (optional - if not provided, args pass through) */
+  inputSchema?: TInputSchema
+
+  /** Zod schema for validating output (optional - if not provided, output passes through) */
+  outputSchema?: TOutputSchema
+
+  /** Whether context (userId) is required for this tool */
+  requiresAuth?: boolean
+
+  /**
+   * The execute function.
+   * Takes validated args and context, returns result data.
+   */
+  execute: (
+    args: TInputSchema extends z.ZodType ? z.infer<TInputSchema> : unknown,
+    context: ExecutionContext
+  ) => Promise<TOutputSchema extends z.ZodType ? z.infer<TOutputSchema> : unknown>
+}
+
+/**
+ * Type for a tool executor function (after wrapping).
+ */
+export type ToolExecutor = (args: unknown, context: ExecutionContext) => Promise<ToolResult>
+
+/**
+ * Helper to create a success result.
+ */
+export function successResult<T>(data: T): ToolResult<T> {
+  return { success: true, data }
+}
+
+/**
+ * Helper to create an error result.
+ */
+export function errorResult(
+  code: string,
+  message: string,
+  details?: Record<string, unknown>
+): ToolResult {
+  return {
+    success: false,
+    error: { code, message, details },
+  }
+}