Merge remote-tracking branch 'origin/staging' into feat/azure-data-explorer

# Conflicts:
#	apps/sim/tools/generated/tool-outputs.ts

Author: waleedlatif1

apps/docs/content/docs/en/tables/using-in-workflows.mdx

@@ -125,7 +125,7 @@ After the run, the table holds the enriched rows. The next run queries them agai
 
 **Iterate row by row.** Wrap a Query → process → update cycle in a [Loop block](/workflows/blocks/loop) to handle one row at a time. This runs sequentially, slower than a batch update but useful when each row needs its own multi-step logic. Inside the loop the Agent reads the current row and an Update Row by ID writes its result.
 
-**Paginate large reads.** Query Rows returns at most 1000 rows. When `totalCount` exceeds your **Limit**, increase **Offset** on each pass (0, then 100, then 200) to walk through the whole table, typically inside a Loop.
+**Paginate large reads.** Query Rows returns at most 1000 rows, and a page can also end early once its rows reach the response size budget — so a page may come back shorter than your **Limit** even when more rows match. Advance **Offset** by the `rowCount` you actually received, not by the Limit you asked for, and keep going while `nextCursor` is set. Stop when `nextCursor` is null. Stepping by the Limit instead skips whatever a short page left behind.
 
 ## Inspecting reads and writes
 

apps/sim/app/api/table/[tableId]/rows/[rowId]/route.ts

@@ -3,6 +3,7 @@ import { userTableRows } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
+import { readClientId } from '@/lib/api/client-id'
 import {
   deleteTableRowContract,
   getTableQuerySchema,
@@ -14,7 +15,7 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { RowData, TableSchema } from '@/lib/table'
 import { updateRow } from '@/lib/table'
-import { signalTableRowsChanged } from '@/lib/table/events'
+import { signalTableRowsChangedByActor } from '@/lib/table/events'
 import { performDeleteTableRow } from '@/lib/table/orchestration'
 import {
   createTableRowsResponse,
@@ -172,7 +173,7 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
     )
 
     // Live-collab: tell open viewers the change landed so they refetch.
-    signalTableRowsChanged(tableId)
+    signalTableRowsChangedByActor(tableId, readClientId(request))
     // Only `null` when a `cancellationGuard` is supplied and the SQL guard
     // rejects the write — this route doesn't pass one, so reaching null is a bug.
     if (!updatedRow) throw new Error('updateRow returned null without a cancellationGuard')
@@ -251,7 +252,7 @@ export const DELETE = withRouteHandler(async (request: NextRequest, context: Row
     }
 
     // Live-collab: tell open viewers the change landed so they refetch.
-    signalTableRowsChanged(tableId)
+    signalTableRowsChangedByActor(tableId, readClientId(request))
 
     return NextResponse.json({
       success: true,

apps/sim/app/api/table/[tableId]/rows/route.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
+import { readClientId } from '@/lib/api/client-id'
 import {
   type BatchInsertTableRowsBodyInput,
   batchUpdateTableRowsBodySchema,
@@ -26,7 +27,7 @@ import {
   validateRowSize,
 } from '@/lib/table'
 import { TableQueryValidationError } from '@/lib/table/errors'
-import { signalTableRowsChanged } from '@/lib/table/events'
+import { signalTableRowsChanged, signalTableRowsChangedByActor } from '@/lib/table/events'
 import { isTablePredicate, predicateToFilter } from '@/lib/table/query-builder/converters'
 import {
   validatePredicateShape,
@@ -254,7 +255,9 @@ export const POST = withRouteHandler(
         table,
         requestId
       )
-      signalTableRowsChanged(tableId)
+      // Attributed unlike the batch path above: the acting tab's insert deliberately avoids
+      // invalidating the rows root to prevent flicker, which an unattributed echo would undo.
+      signalTableRowsChangedByActor(tableId, readClientId(request))
 
       const responseBody = {
         success: true,

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table-event-stream.ts

@@ -5,6 +5,7 @@ import { toast } from '@sim/emcn'
 import { createLogger } from '@sim/logger'
 import { backoffWithJitter } from '@sim/utils/retry'
 import { useQueryClient } from '@tanstack/react-query'
+import { getClientFingerprint } from '@/lib/api/client-id'
 import type { ActiveDispatch } from '@/lib/api/contracts/tables'
 import type {
   RowData,
@@ -245,6 +246,30 @@ export function useTableEventStream({
       }, ROWS_INVALIDATE_DEBOUNCE_MS)
     }
 
+    /**
+     * This tab's fingerprint as it appears on a broadcast it caused. Resolved once, asynchronously;
+     * until it lands `applyEdit` simply takes the refetch path, which is the pre-existing behavior.
+     */
+    let ownFingerprint: string | undefined
+    void getClientFingerprint().then((fingerprint) => {
+      ownFingerprint = fingerprint
+    })
+
+    /**
+     * A manual row edit landed. Refetch the rows so the winning last-write value shows live —
+     * unless this tab is the one that made it.
+     *
+     * The signal names its originator only for writes whose mutation hook already applies the
+     * server's answer to every cached rows query, active or not (single-row create, update,
+     * delete). For those the refetch is pure duplication: on a scrolled table it re-fetches every
+     * loaded page, and on delete it races the refetch the hook itself issued. Other tabs see
+     * someone else's fingerprint and refetch normally; an unattributed edit refetches everywhere.
+     */
+    const applyEdit = (event: Extract<TableEvent, { kind: 'edit' }>): void => {
+      if (event.originatorId && event.originatorId === ownFingerprint) return
+      scheduleRowsInvalidate()
+    }
+
     const applyCell = (event: Extract<TableEvent, { kind: 'cell' }>): void => {
       void snapshotAndMutateRows(queryClient, tableId, (row) => applyCellEventToRow(row, event), {
         cancelInFlight: false,
@@ -445,9 +470,7 @@ export function useTableEventStream({
           else if (entry.event?.kind === 'dispatch') applyDispatch(entry.event)
           else if (entry.event?.kind === 'job') applyJob(entry.event)
           else if (entry.event?.kind === 'usageLimitReached') applyUsageLimit(entry.event)
-          // A collaborator's manual edit: refetch rows (debounced) so the winning
-          // last-write value shows live, in this client's own wire format.
-          else if (entry.event?.kind === 'edit') scheduleRowsInvalidate()
+          else if (entry.event?.kind === 'edit') applyEdit(entry.event)
           // A collaborator changed the table structure: mirror the local
           // invalidateTableSchema set — the definition (exact, so rows stay on the
           // debounce), the run-state + enrichment sibling queries under detail (a group

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

@@ -4,11 +4,32 @@
 import { describe, expect, it } from 'vitest'
 import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
 import {
+  isAgentToolBlock,
   isCustomToolAlreadySelected,
   isMcpToolAlreadySelected,
   isWorkflowAlreadySelected,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/utils'
 
+describe('isAgentToolBlock', () => {
+  it('includes the current File block', () => {
+    expect(isAgentToolBlock({ type: 'file_v5', category: 'blocks', hideFromToolbar: false })).toBe(
+      true
+    )
+  })
+
+  it('excludes hidden blocks such as the legacy File block', () => {
+    expect(isAgentToolBlock({ type: 'file', category: 'blocks', hideFromToolbar: true })).toBe(
+      false
+    )
+  })
+
+  it('does not make every visible core block agent-callable', () => {
+    expect(isAgentToolBlock({ type: 'memory', category: 'blocks', hideFromToolbar: false })).toBe(
+      false
+    )
+  })
+})
+
 describe('isMcpToolAlreadySelected', () => {
   describe('basic functionality', () => {
     it.concurrent('returns false when selectedTools is empty', () => {

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

@@ -46,6 +46,7 @@ import { ToolSubBlockRenderer } from '@/app/workspace/[workspaceId]/w/[workflowI
 import { clearDependentToolParams } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/param-dependents'
 import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
 import {
+  isAgentToolBlock,
   isCustomToolAlreadySelected,
   isMcpToolAlreadySelected,
   isWorkflowAlreadySelected,
@@ -665,21 +666,7 @@ export const ToolInput = memo(function ToolInput({
 
   const customBlockOverlayVersion = useCustomBlockOverlayVersion()
   const toolBlocks = useMemo(() => {
-    const allToolBlocks = getAllBlocks().filter(
-      (block) =>
-        !block.hideFromToolbar &&
-        (block.category === 'tools' ||
-          block.type === 'api' ||
-          block.type === 'webhook_request' ||
-          block.type === 'workflow' ||
-          block.type === 'workflow_input' ||
-          block.type === 'knowledge' ||
-          block.type === 'function' ||
-          block.type === 'table') &&
-        block.type !== 'evaluator' &&
-        block.type !== 'mcp' &&
-        block.type !== 'file'
-    )
+    const allToolBlocks = getAllBlocks().filter(isAgentToolBlock)
     return filterBlocks(allToolBlocks)
   }, [filterBlocks, customBlockOverlayVersion])
 

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

@@ -1,4 +1,27 @@
 import type { StoredTool } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/types'
+import type { BlockConfig } from '@/blocks/types'
+
+const CORE_AGENT_TOOL_TYPES = new Set([
+  'api',
+  'webhook_request',
+  'workflow',
+  'workflow_input',
+  'knowledge',
+  'function',
+  'table',
+  'file_v5',
+])
+
+/**
+ * Checks whether a registered block should appear in the agent tool picker.
+ */
+export function isAgentToolBlock(
+  block: Pick<BlockConfig, 'category' | 'hideFromToolbar' | 'type'>
+): boolean {
+  return (
+    !block.hideFromToolbar && (block.category === 'tools' || CORE_AGENT_TOOL_TYPES.has(block.type))
+  )
+}
 
 /**
  * Checks if an MCP tool is already selected.

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

@@ -364,6 +364,74 @@ describe('SearchModal', () => {
     }
   })
 
+  it('keeps a block above its same-name trigger for the exact-name query', async () => {
+    const Icon = () => null
+    const original = { ...mockSearchState.data }
+    mockSearchState.data = {
+      ...mockSearchState.data,
+      tools: [
+        {
+          id: 'gmail',
+          name: 'Gmail',
+          icon: Icon,
+          bgColor: '#E8453C',
+          type: 'gmail',
+          searchValue: 'gmail gmail',
+        },
+      ],
+      triggers: [{ id: 'gmail', name: 'Gmail', icon: Icon, bgColor: '#E8453C', type: 'gmail' }],
+    }
+
+    try {
+      await act(async () => {
+        root.render(<SearchModal open onOpenChange={vi.fn()} pageContext='workflow' />)
+      })
+
+      await enterSearchQuery('gmail')
+      const rows = Array.from(document.querySelectorAll<HTMLElement>('[cmdk-item]')).map(
+        (el) => el.textContent ?? ''
+      )
+      expect(rows[0]).toContain('Gmail')
+      expect(rows[0]).not.toContain('Gmail Trigger')
+      expect(rows[1]).toContain('Gmail Trigger')
+    } finally {
+      mockSearchState.data = original
+    }
+  })
+
+  it('ranks prefix-matched rows above actions that only contain the letter mid-word', async () => {
+    const Icon = () => null
+    const original = { ...mockSearchState.data }
+    mockSearchState.data = {
+      ...mockSearchState.data,
+      tools: [
+        {
+          id: 'hex',
+          name: 'Hex',
+          icon: Icon,
+          bgColor: '#111',
+          type: 'hex',
+          searchValue: 'hex hex',
+        },
+      ],
+    }
+
+    try {
+      await act(async () => {
+        root.render(<SearchModal open onOpenChange={vi.fn()} pageContext='workflow' />)
+      })
+
+      await enterSearchQuery('h')
+      const rows = Array.from(document.querySelectorAll<HTMLElement>('[cmdk-item]')).map(
+        (el) => el.textContent ?? ''
+      )
+      expect(rows[0]).toContain('Hex')
+      expect(rows.findIndex((row) => row.includes('New chat'))).toBeGreaterThan(0)
+    } finally {
+      mockSearchState.data = original
+    }
+  })
+
   it('puts the workflow verb actions first for their bare-verb queries', async () => {
     const Icon = () => null
     const original = { ...mockSearchState.data }

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

@@ -1054,6 +1054,9 @@ function SearchModalContent({
       ...(pageContext ? rankActionGroup(actionsByGroup.page, 'Actions') : []),
       ...rankActionGroup(actionsByGroup.sim, 'Sim'),
     ]
+    const blockNames = new Set(
+      [...availableBlocks, ...availableTools].map((item) => item.name.toLowerCase())
+    )
 
     return {
       actions: rankedActions.map(({ item, score }) => ({ section: 'actions', item, score })),
@@ -1072,8 +1075,14 @@ function SearchModalContent({
         section: 'triggers',
         item,
         /* The display rename ("Start" → "Start Trigger") costs the exact-name
-           bonus, so a query that IS the trigger's name ranks it like a page row. */
-        score: item.baseName.toLowerCase() === query.toLowerCase() ? PAGE_MATCH_TIER : score,
+           bonus, so a query that IS the trigger's name ranks it like a page row
+           — unless a block shares that name (Gmail, Slack). Then the query names
+           the block first, and the lift would leapfrog its exact-name match. */
+        score:
+          item.baseName.toLowerCase() === query.toLowerCase() &&
+          !blockNames.has(item.baseName.toLowerCase())
+            ? PAGE_MATCH_TIER
+            : score,
       })),
       tools: rank(
         'tools',

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/search-modal/utils.test.ts

@@ -100,6 +100,34 @@ describe('getGlobalSearchResults', () => {
     ).toEqual(['new-chat-action', 'new-chat-result'])
   })
 
+  it('keeps a mid-word-matched action below word-start entity matches', () => {
+    const action = {
+      id: 'create-folder',
+      name: 'Create folder',
+      icon: () => null,
+      context: 'global' as const,
+      run: () => {},
+    }
+    const [actionMatch] = scoreActions([action], 'a')
+    const [blockMatch] = scoreAndSort([{ name: 'Airtable' }], (item) => item.name, 'a')
+
+    expect(actionMatch.score).toBeLessThan(blockMatch.score)
+  })
+
+  it('still biases a word-start action match above entity name matches', () => {
+    const action = {
+      id: 'create-workflow',
+      name: 'Create workflow',
+      icon: () => null,
+      context: 'global' as const,
+      run: () => {},
+    }
+    const [actionMatch] = scoreActions([action], 'w')
+    const [blockMatch] = scoreAndSort([{ name: 'Webhook' }], (item) => item.name, 'w')
+
+    expect(actionMatch.score).toBeGreaterThan(blockMatch.score)
+  })
+
   it('breaks identical visible-name matches by the original section order', () => {
     const workflow = { id: 'new-chat-workflow', name: 'New chat', href: '/new-chat-workflow' }
     const chat = { id: 'new-chat-result', name: 'New chat', href: '/new-chat-result' }