fix(tables): derive select operator guidance from the validator's own sets

Round 2 review. Both bots were right, and the second finding corrected me.

The first fix annotated the column list but left the `filter` PARAMETER
description advertising every operator for every column. That description is
what a model reads when deciding the filter's shape, so the restriction has
to appear there too — it now names the restricted columns inline.

More importantly, the annotation itself was wrong: I omitted isNull and
isNotNull. I had traced the v2 grammar through `predicateToFilter` to the
`$`-prefixed sets in `column-types/select.ts`, which genuinely lack them —
but the v2 query path never goes through that conversion. It compiles
predicates directly in `fieldPredicate`, which gates on a SEPARATE pair of
`FilterOp` sets that do allow both.

Two allowlists for one concept is what made a hand-copied list wrong, so the
v2 sets move next to their v1 siblings in the column-type registry — where
per-type knowledge belongs — and the enrichment now derives its text from
the exact sets the validator gates on. It can no longer drift.

Same correction applied to the block's bestPractices, which carried the
short list too.

Author: mzxchandra

apps/sim/blocks/blocks/table_v2.ts

@@ -242,7 +242,7 @@ export const TableV2Block: BlockConfig<TableQueryV2Response> = {
 - like/ilike use * as the wildcard (e.g. {"field":"name","op":"ilike","value":"*jo*"}).
 - Omit Limit to get the entire matching result in one response — the query fails with a clear error if it exceeds 5MB (narrow with a filter or set a Limit).
 - With a Limit, pages can end at the Limit or the 5MB byte budget, whichever comes first — pass nextCursor back as the cursor and loop until it is null; never infer completion from page size.
-- For substring matching on a text column use ilike with *x*. A select column accepts only a subset of the operators — eq/ne/in/nin when single, contains/ncontains when multi (a multi-select cell holds a list) — and the query is rejected outright on anything else.
+- For substring matching on a text column use ilike with *x*. A select column accepts only a subset of the operators — eq, ne, in, nin when single; contains, ncontains when multi (a multi-select cell holds a list, matched by option name) — plus isEmpty, isNotEmpty, isNull, isNotNull on both. The query is rejected outright on anything else.
 - Use Columns to Return to keep only the fields a downstream step needs (e.g. ["col_email","name"]) — the 5MB budget counts only the returned columns, so narrowing columns is another way to fit a large table; leave it empty for every column.`,
   docsLink: 'https://docs.sim.ai/integrations/table',
   category: 'blocks',

apps/sim/lib/table/column-types/registry.ts

@@ -26,7 +26,9 @@ import { jsonColumnType } from '@/lib/table/column-types/json'
 import { numberColumnType } from '@/lib/table/column-types/number'
 import {
   MULTI_SELECT_OPERATORS,
+  MULTI_SELECT_OPS,
   SINGLE_SELECT_OPERATORS,
+  SINGLE_SELECT_OPS,
   selectColumnType,
 } from '@/lib/table/column-types/select'
 import { stringColumnType } from '@/lib/table/column-types/string'
@@ -36,7 +38,7 @@ import { COLUMN_TYPES, TYPE_SPECIFIC_COLUMN_KEYS } from '@/lib/table/column-type
 import type { ColumnDefinition, JsonValue } from '@/lib/table/types'
 
 export { COLUMN_TYPES }
-export { MULTI_SELECT_OPERATORS, SINGLE_SELECT_OPERATORS }
+export { MULTI_SELECT_OPERATORS, MULTI_SELECT_OPS, SINGLE_SELECT_OPERATORS, SINGLE_SELECT_OPS }
 
 /**
  * Every column type, keyed by id. The annotation is the completeness gate —

apps/sim/lib/table/column-types/select.ts

@@ -8,7 +8,7 @@ import {
   splitMultiSelectInput,
 } from '@/lib/table/select-options'
 import { selectValueToNames } from '@/lib/table/select-values'
-import type { JsonValue } from '@/lib/table/types'
+import type { FilterOp, JsonValue } from '@/lib/table/types'
 
 /**
  * Operators that make sense on a `select` column (whose values are opaque option
@@ -31,6 +31,37 @@ export const MULTI_SELECT_OPERATORS: ReadonlySet<string> = new Set([
   '$empty',
 ])
 
+/**
+ * The same allowlists in the v2 bare-operator grammar, applied inside
+ * `fieldPredicate` so both wire formats gate identically. Not derived from the
+ * `$` sets above by string surgery because the mapping is not 1:1 — `$empty`
+ * splits into `isEmpty`/`isNotEmpty`. `isNull`/`isNotNull` have no `$`
+ * equivalent and are allowed on both: a strict null check is meaningful on any
+ * column, select included.
+ *
+ * Exported so LLM enrichment can DERIVE the operator guidance it gives the
+ * model rather than restating it. A hand-copied list drifts, and the cost of
+ * drift here is a predicate the validator rejects at run time.
+ */
+export const SINGLE_SELECT_OPS: ReadonlySet<FilterOp> = new Set<FilterOp>([
+  'eq',
+  'ne',
+  'in',
+  'nin',
+  'isEmpty',
+  'isNotEmpty',
+  'isNull',
+  'isNotNull',
+])
+export const MULTI_SELECT_OPS: ReadonlySet<FilterOp> = new Set<FilterOp>([
+  'contains',
+  'ncontains',
+  'isEmpty',
+  'isNotEmpty',
+  'isNull',
+  'isNotNull',
+])
+
 export const selectColumnType: ColumnTypeDefinition = {
   id: 'select',
   label: 'Select',

apps/sim/lib/table/llm/enrichment.test.ts

@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import { MULTI_SELECT_OPS, SINGLE_SELECT_OPS } from '@/lib/table/column-types'
 import { enrichTableToolDescription, enrichTableToolParameters } from '@/lib/table/llm/enrichment'
 import type { TableSummary } from '@/lib/table/types'
 
@@ -101,12 +102,23 @@ describe('select columns in the v2 description', () => {
 
   it('names the allowed operators on a single-select column', () => {
     expect(enriched).toContain(
-      'category (single-select; only eq, ne, in, nin, isEmpty, isNotEmpty)'
+      'category (single-select; only eq, ne, in, nin, isEmpty, isNotEmpty, isNull, isNotNull)'
     )
   })
 
   it('names the allowed operators on a multi-select column', () => {
-    expect(enriched).toContain('tags (multi-select; only contains, ncontains, isEmpty, isNotEmpty)')
+    expect(enriched).toContain(
+      'tags (multi-select; only contains, ncontains, isEmpty, isNotEmpty, isNull, isNotNull)'
+    )
+  })
+
+  /**
+   * The list is derived from the sets `fieldPredicate` gates on, so it cannot
+   * drift from the validator the way a hand-copied list did.
+   */
+  it('derives the operator list from the validator sets', () => {
+    for (const op of SINGLE_SELECT_OPS) expect(enriched).toContain(op)
+    for (const op of MULTI_SELECT_OPS) expect(enriched).toContain(op)
   })
 
   it('leaves non-select columns unannotated', () => {
@@ -118,7 +130,7 @@ describe('select columns in the v2 description', () => {
   })
 
   it('steers multi-select matching to contains rather than ilike', () => {
-    expect(enriched).toContain('match it with contains, never ilike')
+    expect(enriched).toContain('match it by option name with contains, never ilike')
   })
 })
 
@@ -154,6 +166,32 @@ describe('enrichTableToolParameters for table_query_rows_v2', () => {
   it('does not enrich a sort property that v2 does not have', () => {
     expect(properties.sort).toBeUndefined()
   })
+
+  /**
+   * The parameter schema is what the model reads when deciding the filter's
+   * shape, so the select restriction has to appear there and not only in the
+   * tool description.
+   */
+  it('carries the select restriction into the filter parameter description', () => {
+    const withSelect = enrichTableToolParameters(
+      V2_SCHEMA,
+      {
+        name: 'Transactions',
+        columns: [
+          { name: 'category', type: 'select', multiple: false },
+          { name: 'tags', type: 'select', multiple: true },
+        ],
+      },
+      'table_query_rows_v2'
+    )
+    expect(withSelect.properties.filter.description).toContain('rejected outright')
+    expect(withSelect.properties.filter.description).toContain('category accept only')
+    expect(withSelect.properties.filter.description).toContain('tags hold a list')
+  })
+
+  it('omits the restriction note when no column restricts operators', () => {
+    expect(properties.filter.description).not.toContain('rejected outright')
+  })
 })
 
 describe('v1 enrichment is unchanged', () => {

apps/sim/lib/table/llm/enrichment.ts

@@ -1,11 +1,4 @@
-/**
- * LLM tool enrichment utilities for table operations.
- *
- * Provides functions to enrich tool descriptions and parameter schemas
- * with table-specific information so LLMs can construct proper queries.
- */
-
-import { columnTypeById } from '@/lib/table/column-types'
+import { columnTypeById, MULTI_SELECT_OPS, SINGLE_SELECT_OPS } from '@/lib/table/column-types'
 import type { TableSummary } from '@/lib/table/types'
 
 /**
@@ -33,6 +26,11 @@ export const FILTER_OPERATIONS = new Set([
  */
 const TABLE_QUERY_ROWS_V2 = 'table_query_rows_v2'
 
+/** The operators a select column actually accepts, read from the validator's own sets. */
+function selectOperatorList(multiple: boolean | undefined): string {
+  return Array.from(multiple ? MULTI_SELECT_OPS : SINGLE_SELECT_OPS).join(', ')
+}
+
 /**
  * Renders one column line for the v2 description.
  *
@@ -44,9 +42,34 @@ const TABLE_QUERY_ROWS_V2 = 'table_query_rows_v2'
  */
 function v2ColumnLine(column: TableSummary['columns'][number]): string {
   if (column.type !== 'select') return `  - ${column.name} (${column.type})`
-  const allowed = column.multiple ? 'contains, ncontains' : 'eq, ne, in, nin'
   const kind = column.multiple ? 'multi-select' : 'single-select'
-  return `  - ${column.name} (${kind}; only ${allowed}, isEmpty, isNotEmpty)`
+  return `  - ${column.name} (${kind}; only ${selectOperatorList(column.multiple)})`
+}
+
+/** Whether any column restricts its operators, i.e. whether the note is worth emitting. */
+function hasSelectColumn(table: TableSummary): boolean {
+  return table.columns.some((column) => column.type === 'select')
+}
+
+/**
+ * A one-line summary of the per-column restrictions, for the `filter` parameter
+ * description. The parameter schema is what a model reads when it is deciding
+ * the SHAPE of the filter, so the restriction has to appear there too and not
+ * only in the tool description.
+ */
+function selectRestrictionNote(table: TableSummary): string {
+  const single = table.columns.filter((c) => c.type === 'select' && !c.multiple).map((c) => c.name)
+  const multi = table.columns.filter((c) => c.type === 'select' && c.multiple).map((c) => c.name)
+  const parts: string[] = []
+  if (single.length > 0) {
+    parts.push(`${single.join(', ')} accept only ${selectOperatorList(false)}`)
+  }
+  if (multi.length > 0) {
+    parts.push(
+      `${multi.join(', ')} hold a list and accept only ${selectOperatorList(true)} (match by option name)`
+    )
+  }
+  return ` Restricted columns - a predicate using any other operator on one is rejected outright: ${parts.join('; ')}.`
 }
 
 /**
@@ -118,7 +141,7 @@ INSTRUCTIONS:
 3. For multiple conditions wrap them in {"all":[...]} for AND or {"any":[...]} for OR; groups nest
 4. Operators: eq, ne, gt, gte, lt, lte, in, nin, like, ilike, nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty
 5. like/ilike use * as the wildcard, e.g. {"field":"name","op":"ilike","value":"*jo*"}
-6. Any column listed below with a restricted operator set accepts ONLY those operators - the query is rejected outright otherwise. A multi-select cell holds a list, so match it with contains, never ilike
+6. Any column listed below with a restricted operator set accepts ONLY those operators - the query is rejected outright otherwise. A multi-select cell holds a list, so match it by option name with contains, never ilike
 7. For substring matching on a text column use ilike with *x*
 8. For ranking queries (highest, lowest, Nth, top N) set order and a small limit, e.g. limit 1 for the highest, 2 for the second highest
 9. Omit limit to return every matching row; the query fails if the result exceeds 5MB, so narrow with a filter instead of guessing a limit
@@ -233,7 +256,7 @@ export function enrichTableToolParameters(
     if (enrichedProperties.filter) {
       enrichedProperties.filter = {
         ...enrichedProperties.filter,
-        description: `Predicate built from the user's question using columns: ${columnNames}. One condition is {"field":"<column>","op":"<operator>","value":<value>}; combine with {"all":[...]} for AND or {"any":[...]} for OR. Operators: eq, ne, gt, gte, lt, lte, in, nin, like, ilike, nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty. Omit only to match every row.`,
+        description: `Predicate built from the user's question using columns: ${columnNames}. One condition is {"field":"<column>","op":"<operator>","value":<value>}; combine with {"all":[...]} for AND or {"any":[...]} for OR. Operators: eq, ne, gt, gte, lt, lte, in, nin, like, ilike, nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty.${hasSelectColumn(table) ? selectRestrictionNote(table) : ''} Omit only to match every row.`,
       }
     }
 

apps/sim/lib/table/sql.ts

@@ -15,7 +15,9 @@ import {
   columnTypeOf,
   filterOperatorsFor,
   MULTI_SELECT_OPERATORS,
+  MULTI_SELECT_OPS,
   SINGLE_SELECT_OPERATORS,
+  SINGLE_SELECT_OPS,
 } from '@/lib/table/column-types'
 import { NAME_PATTERN } from '@/lib/table/constants'
 import { normalizeDateCellValue } from '@/lib/table/dates'
@@ -36,38 +38,12 @@ import type {
  * Re-exported: the `$`-prefixed wire whitelists now live with the `select` type
  * definition, but this module is where callers and tests already look for them.
  */
-export { MULTI_SELECT_OPERATORS, SINGLE_SELECT_OPERATORS }
+export { MULTI_SELECT_OPERATORS, MULTI_SELECT_OPS, SINGLE_SELECT_OPERATORS, SINGLE_SELECT_OPS }
 
 type ColumnType = ColumnDefinition['type']
 type ColumnMap = ReadonlyMap<string, ColumnDefinition>
 
 /**
-/**
- * The same allowlists in the v2 bare-operator grammar, applied inside
- * `fieldPredicate` so both wire formats gate identically. Not derived from the
- * `$` sets above by string surgery because the mapping is not 1:1 — `$empty`
- * splits into `isEmpty`/`isNotEmpty`. `isNull`/`isNotNull` have no `$`
- * equivalent and are allowed on both: a strict null check is meaningful on any
- * column, select included.
- */
-const SINGLE_SELECT_OPS = new Set<FilterOp>([
-  'eq',
-  'ne',
-  'in',
-  'nin',
-  'isEmpty',
-  'isNotEmpty',
-  'isNull',
-  'isNotNull',
-])
-const MULTI_SELECT_OPS = new Set<FilterOp>([
-  'contains',
-  'ncontains',
-  'isEmpty',
-  'isNotEmpty',
-  'isNull',
-  'isNotNull',
-])
 
 /**
  * Returns the Postgres cast needed to compare a JSONB text value of the given