fix(copilot): mount input tables with display-name CSV headers, not column IDs

Author: TheodoreSpeaks

apps/sim/lib/copilot/tools/handlers/function-execute.test.ts

@@ -0,0 +1,118 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockGetTableById, mockListTables, mockQueryRows, mockIsFeatureEnabled } = vi.hoisted(
+  () => ({
+    mockGetTableById: vi.fn(),
+    mockListTables: vi.fn(),
+    mockQueryRows: vi.fn(),
+    mockIsFeatureEnabled: vi.fn(),
+  })
+)
+
+vi.mock('@/lib/table/service', () => ({
+  getTableById: mockGetTableById,
+  listTables: mockListTables,
+}))
+
+vi.mock('@/lib/table/rows/service', () => ({
+  queryRows: mockQueryRows,
+}))
+
+vi.mock('@/lib/core/config/feature-flags', () => ({
+  isFeatureEnabled: mockIsFeatureEnabled,
+}))
+
+vi.mock('@/tools', () => ({
+  executeTool: vi.fn(),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  fetchWorkspaceFileBuffer: vi.fn(),
+  findWorkspaceFileRecord: vi.fn(),
+  getSandboxWorkspaceFilePath: vi.fn(),
+  listWorkspaceFiles: vi.fn(),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-folder-manager', () => ({
+  listWorkspaceFileFolders: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/vfs/path-utils', () => ({
+  decodeVfsPathSegments: vi.fn(),
+  encodeVfsPathSegments: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/vfs/workflow-alias-resolver', () => ({
+  resolveWorkflowAliasForWorkspace: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/vfs/workflow-aliases', () => ({
+  isPlanAliasPath: vi.fn().mockReturnValue(false),
+  workflowAliasSandboxPath: vi.fn(),
+}))
+
+import { resolveInputFiles } from '@/lib/copilot/tools/handlers/function-execute'
+
+describe('resolveInputFiles — table mount', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockIsFeatureEnabled.mockResolvedValue(false)
+  })
+
+  it('mounts a CSV with display-name headers and id-keyed values, never column ids', async () => {
+    mockGetTableById.mockResolvedValue({
+      id: 'tbl_123',
+      workspaceId: 'ws_1',
+      name: 'people',
+      schema: {
+        columns: [
+          { id: 'col_name', name: 'name', type: 'text' },
+          { id: 'col_company', name: 'company', type: 'text' },
+        ],
+      },
+    })
+    mockQueryRows.mockResolvedValue({
+      rows: [
+        { id: 'r1', data: { col_name: 'Ada', col_company: 'Analytical Engine' } },
+        { id: 'r2', data: { col_name: 'Grace', col_company: 'Navy, Inc' } },
+      ],
+    })
+
+    const files = await resolveInputFiles('ws_1', undefined, ['tbl_123'])
+
+    expect(files).toHaveLength(1)
+    const csv = files[0].content
+    const lines = csv.split('\n')
+
+    expect(lines[0]).toBe('name,company')
+    expect(lines[1]).toBe('Ada,Analytical Engine')
+    // Value containing a comma is quoted.
+    expect(lines[2]).toBe('Grace,"Navy, Inc"')
+    // No stable column id leaks into the mounted file.
+    expect(csv).not.toContain('col_name')
+    expect(csv).not.toContain('col_company')
+    expect(files[0].path).toBe('/home/user/tables/tbl_123.csv')
+  })
+
+  it('reads values by column id for legacy name-keyed rows too', async () => {
+    mockGetTableById.mockResolvedValue({
+      id: 'tbl_legacy',
+      workspaceId: 'ws_1',
+      name: 'legacy',
+      schema: {
+        // Legacy column with no id: getColumnId falls back to name.
+        columns: [{ name: 'email', type: 'text' }],
+      },
+    })
+    mockQueryRows.mockResolvedValue({
+      rows: [{ id: 'r1', data: { email: 'a@b.com' } }],
+    })
+
+    const files = await resolveInputFiles('ws_1', undefined, ['tbl_legacy'])
+
+    expect(files[0].content).toBe('email\na@b.com')
+  })
+})

apps/sim/lib/copilot/tools/handlers/function-execute.ts

@@ -3,6 +3,8 @@ import { decodeVfsPathSegments, encodeVfsPathSegments } from '@/lib/copilot/vfs/
 import { resolveWorkflowAliasForWorkspace } from '@/lib/copilot/vfs/workflow-alias-resolver'
 import { isPlanAliasPath, workflowAliasSandboxPath } from '@/lib/copilot/vfs/workflow-aliases'
 import { isFeatureEnabled } from '@/lib/core/config/feature-flags'
+import { getColumnId } from '@/lib/table/column-keys'
+import { formatCsvValue, neutralizeCsvFormula, toCsvRow } from '@/lib/table/export-format'
 import { queryRows } from '@/lib/table/rows/service'
 import { getTableById, listTables } from '@/lib/table/service'
 import { listWorkspaceFileFolders } from '@/lib/uploads/contexts/workspace/workspace-file-folder-manager'
@@ -63,7 +65,7 @@ async function resolveTableRef(
   return tablePathLookup?.get(tableName) ?? null
 }
 
-async function resolveInputFiles(
+export async function resolveInputFiles(
   workspaceId: string,
   inputFiles?: unknown[],
   inputTables?: unknown[],
@@ -265,28 +267,11 @@ async function resolveInputFiles(
       }
       const rows = await queryRows(table, {}, 'copilot-fn-exec')
 
-      const allKeys = new Set(table.schema.columns.map((column) => column.name))
-      for (const row of rows.rows ?? []) {
-        if (row.data && typeof row.data === 'object') {
-          for (const key of Object.keys(row.data as Record<string, unknown>)) {
-            allKeys.add(key)
-          }
-        }
-      }
-      const headers = Array.from(allKeys)
-      const csvLines = [headers.join(',')]
-      for (const row of rows.rows ?? []) {
-        const data = (row.data || {}) as Record<string, unknown>
+      const columns = table.schema.columns
+      const csvLines = [toCsvRow(columns.map((column) => neutralizeCsvFormula(column.name)))]
+      for (const row of rows.rows) {
         csvLines.push(
-          headers
-            .map((h) => {
-              const val = data[h]
-              const str = val === null || val === undefined ? '' : String(val)
-              return str.includes(',') || str.includes('"') || str.includes('\n')
-                ? `"${str.replace(/"/g, '""')}"`
-                : str
-            })
-            .join(',')
+          toCsvRow(columns.map((column) => formatCsvValue(row.data[getColumnId(column)])))
         )
       }
       const csvContent = csvLines.join('\n')