fix(tables): add ncontains to the v2 operator lists and guard the enrichment wiring

Review findings.

The operator list the v2 surfaces advertise omitted `ncontains`, which
`FILTER_OPS` declares and `sql.ts` compiles to a negated ILIKE. An agent
reading the tool schema therefore never knew the operator existed. The list
is spelled out verbatim in several places and had already drifted from its
source of truth on arrival; deriving it from `FILTER_OPS` is the real fix
and is left as follow-up.

The `toolEnrichment` block this branch adds had no test, which is the same
gap that let v2 ship without enrichment in the first place — a refactor
could silently drop it again, and a typo in the tool-id literal degrades to
the generic description with no failure. Pin both halves: the tool declares
the wiring, and the enricher answers in predicate grammar with `filter`
left optional.

Also cover the two `v2PredicateExample` arms an all-numeric or all-text
table takes, and assert the empty-order case the previous test only
executed without checking.

Author: mzxchandra

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

@@ -46,6 +46,30 @@ describe('enrichTableToolDescription for table_query_rows_v2', () => {
     expect(enriched).toContain('Example order: [{"field":"wins","direction":"desc"}]')
   })
 
+  /**
+   * A metrics table is all-numeric and a lookup table is all-text; both are
+   * common, and each picks a different arm of the example builder.
+   */
+  it('builds a numeric example when the table has no string column', () => {
+    const numeric = enrichTableToolDescription(
+      'Query rows.',
+      { name: 'Scores', columns: [{ name: 'wins', type: 'number' }] },
+      'table_query_rows_v2'
+    )
+    expect(numeric).toContain('{"field":"wins","op":"gte","value":10}')
+    expect(numeric).not.toContain('AND group')
+  })
+
+  it('builds a string example when the table has no numeric column', () => {
+    const textual = enrichTableToolDescription(
+      'Query rows.',
+      { name: 'Statuses', columns: [{ name: 'status', type: 'string' }] },
+      'table_query_rows_v2'
+    )
+    expect(textual).toContain('{"field":"status","op":"eq","value":"active"}')
+    expect(textual).not.toContain('"op":"gte"')
+  })
+
   it('omits the example rather than naming a placeholder column', () => {
     const bare = enrichTableToolDescription(
       'Query rows.',
@@ -54,6 +78,7 @@ describe('enrichTableToolDescription for table_query_rows_v2', () => {
     )
     expect(bare).toContain('payload (json)')
     expect(bare).not.toContain('Example filter')
+    expect(bare).not.toContain('Example order')
   })
 })
 

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

@@ -99,7 +99,7 @@ INSTRUCTIONS:
 1. Build the filter yourself from the user's question - do NOT ask for confirmation
 2. A single condition is a plain object: {"field":"<column>","op":"<operator>","value":<value>}
 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, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty
+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. There are no array columns - for substring matching use ilike with *x*
 7. 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
@@ -215,7 +215,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, 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. Omit only to match every row.`,
       }
     }
 

apps/sim/tools/schema-enrichers.test.ts

@@ -17,6 +17,7 @@ vi.mock('@/lib/internal/table/read-schema', () => ({
 }))
 
 import { enrichKBTagsSchema, enrichTableToolSchema } from '@/tools/schema-enrichers'
+import { tableQueryRowsV2Tool } from '@/tools/table/query_rows_v2'
 
 const ORIGINAL_SCHEMA = {
   type: 'object' as const,
@@ -27,6 +28,18 @@ const ORIGINAL_SCHEMA = {
   required: [],
 }
 
+const V2_SCHEMA = {
+  type: 'object' as const,
+  properties: {
+    filter: { type: 'object' },
+    order: { type: 'array' },
+    columns: { type: 'array' },
+    limit: { type: 'number' },
+    cursor: { type: 'string' },
+  },
+  required: [],
+}
+
 const EXECUTOR_ORIGIN = {
   subjectUserId: 'user-1',
   workflowId: 'workflow-1',
@@ -95,6 +108,45 @@ describe('enrichTableToolSchema', () => {
       enrichTableToolSchema('table-1', 'table_query_rows', ORIGINAL_SCHEMA, 'Query rows', {})
     ).rejects.toThrow('Workflow ID is required to enrich table tool schema for table-1')
   })
+
+  /**
+   * The v2 query tool shipped with no enrichment at all, so an agent using it
+   * never saw the table's columns. These pin both halves of the fix: the tool
+   * declares the wiring, and the enricher answers it in v2's grammar rather
+   * than v1's.
+   */
+  it('wires the v2 query tool to the enricher under its own tool id', () => {
+    expect(tableQueryRowsV2Tool.toolEnrichment?.dependsOn).toBe('tableId')
+    expect(tableQueryRowsV2Tool.toolEnrichment?.enrichTool).toBeTypeOf('function')
+  })
+
+  it('enriches the v2 query tool with predicate grammar, not the v1 filter grammar', async () => {
+    const result = await enrichTableToolSchema(
+      'table-1',
+      'table_query_rows_v2',
+      V2_SCHEMA,
+      'Query rows',
+      {
+        workspaceId: 'workspace-1',
+        userId: 'user-1',
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+        executorDelegationOrigin: EXECUTOR_ORIGIN,
+      }
+    )
+
+    expect(result.description).toContain('Table "Customers" columns:')
+    expect(result.description).toContain('"op":"gte"')
+    expect(result.description).not.toContain('$eq')
+    expect(result.parameters.properties.filter).toMatchObject({
+      description: expect.stringContaining('email, score'),
+    })
+    expect(result.parameters.properties.cursor).toMatchObject({
+      description: expect.stringContaining('nextCursor'),
+    })
+    // v2 returns every row when the filter is omitted, so it must stay optional.
+    expect(result.parameters.required).not.toContain('filter')
+  })
 })
 
 describe('enrichKBTagsSchema', () => {

apps/sim/tools/table/query_rows_v2.ts

@@ -16,7 +16,7 @@ export const tableQueryRowsV2Tool: InternalToolConfig<TableRowQueryV2Params, Tab
       'Query rows with a typed predicate filter and cursor pagination. ' +
       'A single filter can be a plain condition: `{"field":"wins","op":"gte","value":10}`. ' +
       'Use `all` (AND) or `any` (OR) groups for multiple or nested conditions. Operators: eq, ne, gt, gte, lt, lte, in, nin, like, ilike, ' +
-      'nlike, nilike, contains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty. ' +
+      'nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty. ' +
       'Order is a sort spec, e.g. `[{"field":"wins","direction":"desc"}]`. Omit limit to return the entire result — ' +
       'the query fails if it exceeds the 5MB budget (narrow with a filter or set a limit). With a limit, ' +
       'a page can end early at the byte budget: a non-null nextCursor means more rows exist — pass it back ' +