The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
perf(mcp): generate database tool input schemas as plain JSON Schema (#27158)
Charles Bochet2f7611b1d155
diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock.ts b/packages/twenty-server/src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock.tsnew file mode 100644index 00000000000..dc90eecf927--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock.ts@@ -0,0 +1,14 @@+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';++export const getToolSchemaFieldMock = (+ overrides: Pick<FlatFieldMetadata, 'name' | 'type'> &+ Partial<FlatFieldMetadata>,+): FlatFieldMetadata =>+ getFlatFieldMetadataMock({+ id: `field-id-${overrides.name}`,+ universalIdentifier: overrides.name,+ objectMetadataId: 'object-metadata-id',+ description: null,+ ...overrides,+ });diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/field-filters.json-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/field-filters.json-schema.spec.tsnew file mode 100644index 00000000000..04bc67408bc--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/field-filters.json-schema.spec.ts@@ -0,0 +1,110 @@+import { FieldMetadataType, RelationType } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { generateFieldFilterJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/field-filters.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { getToolSchemaFieldMock } from 'src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';++const generateResolvedFilter = (field: FlatFieldMetadata) => {+ const definitions: JsonSchemaDefinitions = {};+ const filter = generateFieldFilterJsonSchema({ field, definitions });+ const definitionName = filter?.$ref?.replace('#/$defs/', '');++ return isDefined(definitionName) ? definitions[definitionName] : filter;+};++describe('generateFieldFilterJsonSchema', () => {+ it('should expose pattern operators at the root of text filters', () => {+ expect(+ Object.keys(+ generateResolvedFilter(+ getToolSchemaFieldMock({+ name: 'title',+ type: FieldMetadataType.TEXT,+ }),+ )?.properties ?? {},+ ),+ ).toEqual(expect.arrayContaining(['eq', 'ilike', 'startsWith', 'is']));+ });++ it('should filter rich text through its markdown sub-field', () => {+ expect(+ Object.keys(+ generateResolvedFilter(+ getToolSchemaFieldMock({+ name: 'body',+ type: FieldMetadataType.RICH_TEXT,+ }),+ )?.properties ?? {},+ ),+ ).toEqual(['markdown']);+ });++ it('should filter many-to-one morph relations by the related record id', () => {+ expect(+ Object.keys(+ generateResolvedFilter(+ getToolSchemaFieldMock({+ name: 'targetPerson',+ type: FieldMetadataType.MORPH_RELATION,+ settings: { relationType: RelationType.MANY_TO_ONE },+ }),+ )?.properties ?? {},+ ),+ ).toEqual(['eq', 'neq', 'in', 'is']);+ });++ it('should not filter one-to-many relations', () => {+ expect(+ generateFieldFilterJsonSchema({+ field: getToolSchemaFieldMock({+ name: 'people',+ type: FieldMetadataType.RELATION,+ settings: { relationType: RelationType.ONE_TO_MANY },+ }),+ definitions: {},+ }),+ ).toBeNull();+ });++ it('should restrict select filters to the field options', () => {+ expect(+ generateResolvedFilter(+ getToolSchemaFieldMock({+ name: 'stage',+ type: FieldMetadataType.SELECT,+ options: [+ {+ id: 'new',+ value: 'NEW',+ label: 'New',+ color: 'blue',+ position: 0,+ },+ {+ id: 'won',+ value: 'WON',+ label: 'Won',+ color: 'green',+ position: 1,+ },+ ],+ }),+ )?.properties?.eq,+ ).toEqual({ description: 'Equals', type: 'string', enum: ['NEW', 'WON'] });+ });++ it('should not filter select fields without options', () => {+ expect(+ generateFieldFilterJsonSchema({+ field: getToolSchemaFieldMock({+ name: 'stage',+ type: FieldMetadataType.SELECT,+ options: [],+ }),+ definitions: {},+ }),+ ).toBeNull();+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/find-tool.json-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/find-tool.json-schema.spec.tsnew file mode 100644index 00000000000..04b6a720f0f--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/find-tool.json-schema.spec.ts@@ -0,0 +1,99 @@+import { FieldMetadataType, RelationType } from 'twenty-shared/types';++import { generateFindToolInputSchema } from 'src/engine/core-modules/record-crud/json-schemas/find-tool.json-schema';+import { getToolSchemaFieldMock } from 'src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock';++const COMPANY_FIELDS = [+ getToolSchemaFieldMock({ name: 'name', type: FieldMetadataType.TEXT }),+ getToolSchemaFieldMock({ name: 'address', type: FieldMetadataType.ADDRESS }),+ getToolSchemaFieldMock({+ name: 'accountOwner',+ type: FieldMetadataType.RELATION,+ settings: { relationType: RelationType.MANY_TO_ONE },+ }),+ getToolSchemaFieldMock({+ name: 'createdAt',+ type: FieldMetadataType.DATE_TIME,+ isSystem: true,+ }),+ getToolSchemaFieldMock({+ name: 'deletedAt',+ type: FieldMetadataType.DATE_TIME,+ isSystem: true,+ }),+ getToolSchemaFieldMock({+ name: 'people',+ type: FieldMetadataType.RELATION,+ settings: { relationType: RelationType.ONE_TO_MANY },+ }),+];++const generateSchema = (restrictedFields = {}) =>+ generateFindToolInputSchema({+ objectMetadata: { fields: COMPANY_FIELDS },+ restrictedFields,+ });++const DIRECTION_REFERENCE = { $ref: '#/$defs/OrderByDirection' };++describe('generateFindToolInputSchema', () => {+ it('should sort scalar and many-to-one fields by direction and composite fields by sub-field', () => {+ expect(generateSchema()).toMatchObject({+ properties: {+ orderBy: {+ items: {+ properties: {+ name: DIRECTION_REFERENCE,+ accountOwnerId: DIRECTION_REFERENCE,+ createdAt: DIRECTION_REFERENCE,+ address: {+ properties: {+ addressCity: DIRECTION_REFERENCE,+ addressCountry: DIRECTION_REFERENCE,+ },+ additionalProperties: false,+ },+ },+ additionalProperties: false,+ },+ },+ },+ });+ });++ it('should not offer sorting on one-to-many, deleted-at or unreadable fields', () => {+ expect(+ generateSchema({ 'field-id-name': { canRead: false } }),+ ).toMatchObject({+ properties: {+ orderBy: {+ items: {+ properties: expect.not.objectContaining({+ people: expect.anything(),+ deletedAt: expect.anything(),+ name: expect.anything(),+ }),+ },+ },+ },+ });+ });++ it('should expose field filters and logical operators as arguments', () => {+ expect(generateSchema()).toMatchObject({+ properties: {+ name: { $ref: '#/$defs/TextFilter' },+ accountOwnerId: { $ref: '#/$defs/UuidFilter' },+ or: { items: { $ref: '#/$defs/RecordFilter' } },+ not: { $ref: '#/$defs/RecordFilter' },+ },+ required: ['select'],+ });+ });++ it('should not offer filtering on unreadable fields', () => {+ expect(+ generateSchema({ 'field-id-name': { canRead: false } }).properties?.name,+ ).toBeUndefined();+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/group-by-tool.json-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/group-by-tool.json-schema.spec.tsnew file mode 100644index 00000000000..ebacba081e8--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/group-by-tool.json-schema.spec.ts@@ -0,0 +1,122 @@+import { FieldMetadataType } from 'twenty-shared/types';++import { generateGroupByToolInputSchema } from 'src/engine/core-modules/record-crud/json-schemas/group-by-tool.json-schema';+import { getToolSchemaFieldMock } from 'src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock';++const FIELDS = [+ getToolSchemaFieldMock({+ name: 'tags',+ type: FieldMetadataType.MULTI_SELECT,+ options: [+ {+ id: 'radius',+ value: 'RADIUS',+ label: 'Radius',+ color: 'blue',+ position: 0,+ },+ { id: 'pam', value: 'PAM', label: 'PAM', color: 'red', position: 1 },+ ],+ }),+ getToolSchemaFieldMock({ name: 'aliases', type: FieldMetadataType.ARRAY }),+ getToolSchemaFieldMock({ name: 'name', type: FieldMetadataType.TEXT }),+ getToolSchemaFieldMock({+ name: 'createdAt',+ type: FieldMetadataType.DATE_TIME,+ }),+];++const buildUnnestEntry = (fieldName: string) => ({+ type: 'object',+ properties: {+ [fieldName]: {+ anyOf: [+ { type: 'boolean', const: true },+ {+ type: 'object',+ properties: { unnest: { type: 'boolean', const: true } },+ required: ['unnest'],+ additionalProperties: false,+ },+ ],+ },+ },+ required: [fieldName],+ additionalProperties: false,+});++describe('generateGroupByToolInputSchema', () => {+ it('should publish whole-array and strict unnest shapes for multi-value fields', () => {+ expect(+ generateGroupByToolInputSchema({ objectMetadata: { fields: FIELDS } }),+ ).toMatchObject({+ properties: {+ groupBy: {+ items: {+ anyOf: expect.arrayContaining([+ buildUnnestEntry('tags'),+ buildUnnestEntry('aliases'),+ ]),+ },+ },+ },+ additionalProperties: false,+ });+ });++ it('should group date fields through the shared date configuration', () => {+ expect(+ generateGroupByToolInputSchema({ objectMetadata: { fields: FIELDS } }),+ ).toMatchObject({+ properties: {+ groupBy: {+ items: {+ anyOf: expect.arrayContaining([+ expect.objectContaining({+ properties: { createdAt: { $ref: '#/$defs/DateGroupBy' } },+ }),+ ]),+ },+ },+ },+ $defs: { DateGroupBy: expect.objectContaining({ type: 'object' }) },+ });+ });++ it('should describe the unnest rule and overlapping group counts', () => {+ expect(+ generateGroupByToolInputSchema({ objectMetadata: { fields: FIELDS } }),+ ).toMatchObject({+ properties: {+ groupBy: {+ description: expect.stringMatching(+ /At most one entry can use unnest\..*totals can exceed the record count.*aliases \(multi-value,/,+ ),+ },+ },+ });+ });++ it('should omit unreadable fields from the grouping choices', () => {+ expect(+ generateGroupByToolInputSchema({+ objectMetadata: { fields: FIELDS },+ restrictedFields: { 'field-id-tags': { canRead: false } },+ }),+ ).toMatchObject({+ properties: {+ groupBy: {+ items: {+ anyOf: expect.not.arrayContaining([buildUnnestEntry('tags')]),+ },+ },+ },+ });+ });++ it('should not generate a schema when no field can be grouped by', () => {+ expect(+ generateGroupByToolInputSchema({ objectMetadata: { fields: [] } }),+ ).toBeNull();+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/record-properties.json-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/record-properties.json-schema.spec.tsnew file mode 100644index 00000000000..d23f8c68462--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/__tests__/record-properties.json-schema.spec.ts@@ -0,0 +1,68 @@+import { FieldMetadataType, RelationType } from 'twenty-shared/types';++import { generateRecordPropertiesJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema';+import { getToolSchemaFieldMock } from 'src/engine/core-modules/record-crud/__mocks__/get-tool-schema-field-mock';++const FIELDS = [+ getToolSchemaFieldMock({+ name: 'id',+ type: FieldMetadataType.UUID,+ isNullable: false,+ }),+ getToolSchemaFieldMock({+ name: 'name',+ type: FieldMetadataType.TEXT,+ isNullable: false,+ description: 'Deal name',+ }),+ getToolSchemaFieldMock({ name: 'amount', type: FieldMetadataType.CURRENCY }),+ getToolSchemaFieldMock({+ name: 'company',+ type: FieldMetadataType.RELATION,+ isNullable: false,+ settings: { relationType: RelationType.MANY_TO_ONE },+ }),+ getToolSchemaFieldMock({+ name: 'tasks',+ type: FieldMetadataType.RELATION,+ settings: { relationType: RelationType.ONE_TO_MANY },+ }),+];++describe('generateRecordPropertiesJsonSchema', () => {+ it('should describe writable fields and require the non-nullable ones', () => {+ expect(+ generateRecordPropertiesJsonSchema({+ objectMetadata: { fields: FIELDS },+ definitions: {},+ }),+ ).toEqual({+ properties: {+ name: { description: 'Deal name', type: 'string' },+ amount: { $ref: '#/$defs/CurrencyValue' },+ companyId: { $ref: '#/$defs/UuidValue' },+ },+ required: ['name', 'companyId'],+ });+ });++ it('should not require any field in a partial update', () => {+ expect(+ generateRecordPropertiesJsonSchema({+ objectMetadata: { fields: FIELDS },+ definitions: {},+ isPartial: true,+ }).required,+ ).toEqual([]);+ });++ it('should skip fields the role cannot update', () => {+ expect(+ generateRecordPropertiesJsonSchema({+ objectMetadata: { fields: FIELDS },+ definitions: {},+ restrictedFields: { 'field-id-name': { canUpdate: false } },+ }).properties,+ ).not.toHaveProperty('name');+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/bulk-delete-tool.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/bulk-delete-tool.json-schema.tsnew file mode 100644index 00000000000..8c52f6126a8--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/bulk-delete-tool.json-schema.ts@@ -0,0 +1,35 @@+import { type JSONSchema7 } from 'json-schema';+import { type RestrictedFieldsPermissions } from 'twenty-shared/types';++import { generateRecordFilterJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';++export const generateBulkDeleteToolInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 => {+ const definitions: JsonSchemaDefinitions = {};++ const { reference: filterReference } = generateRecordFilterJsonSchema({+ objectMetadata,+ restrictedFields,+ definitions,+ });++ return buildObjectJsonSchema({+ properties: {+ filter: {+ description:+ 'Filter to select which records to delete. Supports field-level filters and logical operators (or, and, not). WARNING: A broad filter may delete many records at once. Always verify the filter scope with a find query first.',+ ...filterReference,+ },+ },+ required: ['filter'],+ definitions,+ });+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/delete-tool.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/delete-tool.json-schema.tsnew file mode 100644index 00000000000..1e31939ddf2--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/delete-tool.json-schema.ts@@ -0,0 +1,13 @@+import { type JSONSchema7 } from 'json-schema';++export const DELETE_TOOL_INPUT_SCHEMA: JSONSchema7 = {+ type: 'object',+ properties: {+ id: {+ description: 'The unique UUID of the record to delete',+ type: 'string',+ format: 'uuid',+ },+ },+ required: ['id'],+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/field-filters.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/field-filters.json-schema.tsnew file mode 100644index 00000000000..53a5a3a9043--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/field-filters.json-schema.ts@@ -0,0 +1,124 @@+import { type JSONSchema7 } from 'json-schema';+import { FieldMetadataType } from 'twenty-shared/types';++import { SHARED_FILTER_JSON_SCHEMAS } from 'src/engine/core-modules/record-crud/json-schemas/shared-filter-definitions.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { getFieldOptionValues } from 'src/engine/core-modules/record-crud/utils/get-field-option-values.util';+import { referenceJsonSchemaDefinition } from 'src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';++type SharedFilterName = keyof typeof SHARED_FILTER_JSON_SCHEMAS;++const SHARED_FILTER_NAME_BY_FIELD_TYPE: Partial<+ Record<FieldMetadataType, SharedFilterName>+> = {+ [FieldMetadataType.UUID]: 'UuidFilter',+ [FieldMetadataType.TEXT]: 'TextFilter',+ [FieldMetadataType.RICH_TEXT]: 'RichTextFilter',+ [FieldMetadataType.NUMBER]: 'NumberFilter',+ [FieldMetadataType.NUMERIC]: 'NumberFilter',+ [FieldMetadataType.POSITION]: 'NumberFilter',+ [FieldMetadataType.BOOLEAN]: 'BooleanFilter',+ [FieldMetadataType.DATE_TIME]: 'DateFilter',+ [FieldMetadataType.DATE]: 'DateFilter',+ [FieldMetadataType.ARRAY]: 'ArrayFilter',+ [FieldMetadataType.CURRENCY]: 'CurrencyFilter',+ [FieldMetadataType.FULL_NAME]: 'FullNameFilter',+ [FieldMetadataType.ADDRESS]: 'AddressFilter',+ [FieldMetadataType.EMAILS]: 'EmailsFilter',+ [FieldMetadataType.PHONES]: 'PhonesFilter',+ [FieldMetadataType.LINKS]: 'LinksFilter',+};++const referenceSharedFilter = ({+ definitions,+ name,+}: {+ definitions: JsonSchemaDefinitions;+ name: SharedFilterName;+}): JSONSchema7 =>+ referenceJsonSchemaDefinition({+ definitions,+ name,+ schema: SHARED_FILTER_JSON_SCHEMAS[name],+ });++const buildOptionsFilter = ({+ field,+ optionValues,+ nullCheck,+}: {+ field: FlatFieldMetadata;+ optionValues: string[];+ nullCheck: JSONSchema7;+}): JSONSchema7 => {+ const option: JSONSchema7 = { type: 'string', enum: optionValues };++ if (field.type === FieldMetadataType.MULTI_SELECT) {+ return {+ type: 'object',+ properties: {+ in: {+ description: 'Contains any of these values',+ type: 'array',+ items: option,+ },+ is: nullCheck,+ isEmptyArray: { description: 'Is empty array', type: 'boolean' },+ },+ };+ }++ return {+ type: 'object',+ properties: {+ eq: { description: 'Equals', ...option },+ ...(field.type === FieldMetadataType.SELECT && {+ neq: { description: 'Not equals', ...option },+ }),+ in: { description: 'In array of values', type: 'array', items: option },+ is: nullCheck,+ },+ };+};++export const generateFieldFilterJsonSchema = ({+ field,+ definitions,+}: {+ field: FlatFieldMetadata;+ definitions: JsonSchemaDefinitions;+}): JSONSchema7 | null => {+ const nullCheck = referenceSharedFilter({ definitions, name: 'NullCheck' });++ if (isMorphOrRelationFlatFieldMetadata(field)) {+ return isManyToOneFlatFieldMetadata(field)+ ? referenceSharedFilter({ definitions, name: 'UuidFilter' })+ : null;+ }++ if (+ field.type === FieldMetadataType.SELECT ||+ field.type === FieldMetadataType.MULTI_SELECT ||+ field.type === FieldMetadataType.RATING+ ) {+ const optionValues = getFieldOptionValues(field);++ if (optionValues.length === 0) {+ return null;+ }++ return referenceJsonSchemaDefinition({+ definitions,+ name: `${field.name}Filter`,+ schema: buildOptionsFilter({ field, optionValues, nullCheck }),+ });+ }++ return referenceSharedFilter({+ definitions,+ name: SHARED_FILTER_NAME_BY_FIELD_TYPE[field.type] ?? 'DefaultFilter',+ });+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/find-one-tool.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/find-one-tool.json-schema.tsnew file mode 100644index 00000000000..09731b91dc1--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/find-one-tool.json-schema.ts@@ -0,0 +1,24 @@+import { type JSONSchema7 } from 'json-schema';++export const FIND_ONE_TOOL_INPUT_SCHEMA: JSONSchema7 = {+ type: 'object',+ properties: {+ id: {+ description: 'The unique UUID of the record to retrieve',+ type: 'string',+ format: 'uuid',+ },+ select: {+ description:+ 'Fields to include in the response. Required. ' ++ "Use '*' to return all fields. " ++ 'Relation fields resolve to related records as {id, label} summaries: ' ++ 'MANY_TO_ONE returns a single object (or select the <name>Id FK column for just the id), ' ++ 'ONE_TO_MANY returns up to 60 related records.',+ minItems: 1,+ type: 'array',+ items: { type: 'string' },+ },+ },+ required: ['id', 'select'],+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/find-tool.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/find-tool.json-schema.tsnew file mode 100644index 00000000000..aa1fd5f0d8a--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/find-tool.json-schema.ts@@ -0,0 +1,61 @@+import { type JSONSchema7 } from 'json-schema';+import { type RestrictedFieldsPermissions } from 'twenty-shared/types';++import { generateRecordOrderByJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/order-by.json-schema';+import { generateRecordFilterJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';++export const generateFindToolInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 => {+ const definitions: JsonSchemaDefinitions = {};++ const { properties: filterProperties } = generateRecordFilterJsonSchema({+ objectMetadata,+ restrictedFields,+ definitions,+ });++ return buildObjectJsonSchema({+ properties: {+ limit: {+ description:+ 'Maximum number of records to return (default: 10, max: 100). Start small and increase only if needed.',+ default: 10,+ type: 'integer',+ exclusiveMinimum: 0,+ },+ offset: {+ description: 'Number of records to skip (default: 0)',+ default: 0,+ type: 'integer',+ },+ orderBy: generateRecordOrderByJsonSchema({+ objectMetadata,+ restrictedFields,+ definitions,+ }),+ select: {+ description:+ `Fields to include in the response. Required. ` ++ `Use '*' to return all fields, or list specific field names. ` ++ `Relation fields resolve to related records as {id, label} summaries: ` ++ `MANY_TO_ONE returns a single object (or select the '<name>Id' FK column for just the id), ` ++ `ONE_TO_MANY returns up to 60 related records. ` ++ `For more fields or more records, query the related object directly. `,+ minItems: 1,+ type: 'array',+ items: { type: 'string' },+ },+ ...filterProperties,+ },+ required: ['select'],+ definitions,+ });+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/group-by-tool.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/group-by-tool.json-schema.tsnew file mode 100644index 00000000000..c5201ae284b--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/group-by-tool.json-schema.ts@@ -0,0 +1,260 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type JSONSchema7 } from 'json-schema';+import {+ AggregateOperations,+ FirstDayOfTheWeek,+ ObjectRecordGroupByDateGranularity,+ type RestrictedFieldsPermissions,+} from 'twenty-shared/types';+import {+ isFieldMetadataArrayKind,+ isFieldMetadataDateKind,+ isFieldMetadataSupportedInGroupBy,+} from 'twenty-shared/utils';++import { getAvailableAggregationsFromObjectFields } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';+import { generateRecordFilterJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';+import { referenceJsonSchemaDefinition } from 'src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util';+import { getGroupableSubFieldsForCompositeType } from 'src/engine/metadata-modules/field-metadata/utils/get-groupable-sub-fields-for-composite-type.util';+import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';++const TRUE_JSON_SCHEMA: JSONSchema7 = { type: 'boolean', const: true };++const DATE_GROUP_BY_JSON_SCHEMA: JSONSchema7 = {+ description: 'Date field grouping configuration',+ type: 'object',+ properties: {+ granularity: {+ description: 'Date grouping granularity. Default: MONTH.',+ default: ObjectRecordGroupByDateGranularity.MONTH,+ type: 'string',+ enum: Object.values(ObjectRecordGroupByDateGranularity).filter(+ (granularity) =>+ granularity !== ObjectRecordGroupByDateGranularity.NONE,+ ),+ },+ weekStartDay: {+ description:+ 'First day of week (MONDAY, SUNDAY, SATURDAY). Only used when granularity is WEEK.',+ type: 'string',+ enum: Object.values(FirstDayOfTheWeek),+ },+ timeZone: {+ description:+ 'IANA timezone for date groupings (e.g. "America/New_York"). Default: UTC.',+ default: 'UTC',+ type: 'string',+ },+ },+ additionalProperties: false,+};++const buildSingleKeyObject = ({+ key,+ value,+}: {+ key: string;+ value: JSONSchema7;+}): JSONSchema7 =>+ buildObjectJsonSchema({+ properties: { [key]: value },+ required: [key],+ isStrict: true,+ });++const buildGroupByEntries = ({+ objectMetadata,+ restrictedFields,+ definitions,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+ definitions: JsonSchemaDefinitions;+}): { schema: JSONSchema7; label: string }[] =>+ objectMetadata.fields+ .filter(+ (field) =>+ restrictedFields?.[field.id]?.canRead !== false &&+ isFieldMetadataSupportedInGroupBy(field),+ )+ .flatMap((field) => {+ if (isMorphOrRelationFlatFieldMetadata(field)) {+ if (!isManyToOneFlatFieldMetadata(field)) {+ return [];+ }++ const joinColumnName = computeMorphOrRelationFieldJoinColumnName({+ name: field.name,+ });++ return [+ {+ schema: buildSingleKeyObject({+ key: joinColumnName,+ value: TRUE_JSON_SCHEMA,+ }),+ label: joinColumnName,+ },+ ];+ }++ if (isFieldMetadataDateKind(field.type)) {+ return [+ {+ schema: buildSingleKeyObject({+ key: field.name,+ value: referenceJsonSchemaDefinition({+ definitions,+ name: 'DateGroupBy',+ schema: DATE_GROUP_BY_JSON_SCHEMA,+ }),+ }),+ label: `${field.name} (date)`,+ },+ ];+ }++ if (isCompositeFieldMetadataType(field.type)) {+ return (getGroupableSubFieldsForCompositeType(field.type) ?? []).map(+ (subField) => ({+ schema: buildSingleKeyObject({+ key: field.name,+ value: buildSingleKeyObject({+ key: subField,+ value: TRUE_JSON_SCHEMA,+ }),+ }),+ label: `${field.name}.${subField}`,+ }),+ );+ }++ if (isFieldMetadataArrayKind(field.type)) {+ return [+ {+ schema: buildSingleKeyObject({+ key: field.name,+ value: {+ anyOf: [+ TRUE_JSON_SCHEMA,+ buildSingleKeyObject({+ key: 'unnest',+ value: TRUE_JSON_SCHEMA,+ }),+ ],+ },+ }),+ label: `${field.name} (multi-value, {"${field.name}": {"unnest": true}} counts each value)`,+ },+ ];+ }++ return [+ {+ schema: buildSingleKeyObject({+ key: field.name,+ value: TRUE_JSON_SCHEMA,+ }),+ label: field.name,+ },+ ];+ });++export const generateGroupByToolInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 | null => {+ const definitions: JsonSchemaDefinitions = {};++ const groupByEntries = buildGroupByEntries({+ objectMetadata,+ restrictedFields,+ definitions,+ });++ if (groupByEntries.length === 0) {+ return null;+ }++ const { properties: filterProperties } = generateRecordFilterJsonSchema({+ objectMetadata,+ restrictedFields,+ definitions,+ });++ const availableAggregations = getAvailableAggregationsFromObjectFields(+ objectMetadata.fields.filter(+ (field) => restrictedFields?.[field.id]?.canRead !== false,+ ),+ );++ const availableAggregateFieldNames = Array.from(+ new Set(+ Object.values(availableAggregations)+ .filter(+ (aggregation) =>+ aggregation.aggregateOperation !== AggregateOperations.COUNT,+ )+ .map((aggregation) =>+ isNonEmptyString(aggregation.subFieldForNumericOperation)+ ? `${aggregation.fromField}.${aggregation.subFieldForNumericOperation}`+ : aggregation.fromField,+ ),+ ),+ );++ const groupByEntrySchemas = groupByEntries.map(({ schema }) => schema);++ return buildObjectJsonSchema({+ properties: {+ groupBy: {+ description: `Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: ${groupByEntries.map(({ label }) => label).join(', ')}.`,+ minItems: 1,+ maxItems: 2,+ type: 'array',+ items:+ groupByEntrySchemas.length === 1+ ? groupByEntrySchemas[0]+ : { anyOf: groupByEntrySchemas },+ },+ aggregateOperation: {+ description:+ 'Aggregate operation to apply per group. Default: COUNT. Any operation other than COUNT requires aggregateFieldName.',+ default: AggregateOperations.COUNT,+ type: 'string',+ enum: Object.keys(AggregateOperations),+ },+ aggregateFieldName: {+ description: `Field to aggregate. Required for any operation other than COUNT. Available fields: ${availableAggregateFieldNames.join(', ')}.`,+ type: 'string',+ },+ limit: {+ description:+ 'Maximum number of groups to return (default: 50, max: 100).',+ default: 50,+ type: 'integer',+ exclusiveMinimum: 0,+ },+ orderBy: {+ description:+ 'Order groups by aggregate value. DESC (default) gives "top N" behavior.',+ default: 'DESC',+ type: 'string',+ enum: ['ASC', 'DESC'],+ },+ ...filterProperties,+ },+ required: ['groupBy'],+ definitions,+ isStrict: true,+ });+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/order-by.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/order-by.json-schema.tsnew file mode 100644index 00000000000..a0b9d46f5b8--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/order-by.json-schema.ts@@ -0,0 +1,103 @@+import { type JSONSchema7 } from 'json-schema';+import {+ compositeTypeDefinitions,+ type RestrictedFieldsPermissions,+} from 'twenty-shared/types';+import {+ isDefined,+ shouldExcludeFieldFromAgentToolSchema,+} from 'twenty-shared/utils';++import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';+import { referenceJsonSchemaDefinition } from 'src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util';+import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';++const ORDER_BY_DIRECTION_JSON_SCHEMA: JSONSchema7 = {+ type: 'string',+ enum: ['AscNullsFirst', 'AscNullsLast', 'DescNullsFirst', 'DescNullsLast'],+};++// Mirrors the GraphQL orderBy input, so the shape advertised for each field+// (direction for scalars, sub-fields for composites) is the one the orderBy+// resolver accepts for this object+export const generateRecordOrderByJsonSchema = ({+ objectMetadata,+ restrictedFields,+ definitions,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+ definitions: JsonSchemaDefinitions;+}): JSONSchema7 => {+ const direction = referenceJsonSchemaDefinition({+ definitions,+ name: 'OrderByDirection',+ schema: ORDER_BY_DIRECTION_JSON_SCHEMA,+ });++ const orderByItemProperties: Record<string, JSONSchema7> = {};++ for (const field of objectMetadata.fields) {+ // System fields stay sortable: agents sort by createdAt, updatedAt and+ // position to get recent or first records+ if (+ shouldExcludeFieldFromAgentToolSchema({+ fieldName: field.name,+ isSystem: false,+ excludeId: false,+ }) ||+ restrictedFields?.[field.id]?.canRead === false+ ) {+ continue;+ }++ if (isMorphOrRelationFlatFieldMetadata(field)) {+ if (isManyToOneFlatFieldMetadata(field)) {+ orderByItemProperties[+ computeMorphOrRelationFieldJoinColumnName({ name: field.name })+ ] = direction;+ }++ continue;+ }++ if (!isCompositeFieldMetadataType(field.type)) {+ orderByItemProperties[field.name] = direction;++ continue;+ }++ const compositeType = compositeTypeDefinitions.get(field.type);++ if (!isDefined(compositeType)) {+ continue;+ }++ orderByItemProperties[field.name] = {+ type: 'object',+ properties: Object.fromEntries(+ compositeType.properties+ .filter((property) => property.hidden !== true)+ .map((property) => [property.name, direction]),+ ),+ additionalProperties: false,+ };+ }++ return {+ description:+ 'Array of sort criteria, one field per item. Use "DescNullsLast" for descending (top/largest), "AscNullsFirst" for ascending (bottom/smallest).',+ type: 'array',+ items: {+ description:+ 'Object with exactly ONE property. Scalar fields take a direction string; composite fields take an object with one sub-field. Never use dot-notation keys.',+ type: 'object',+ properties: orderByItemProperties,+ additionalProperties: false,+ },+ };+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema.tsnew file mode 100644index 00000000000..dcd00200314--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema.ts@@ -0,0 +1,85 @@+import { type JSONSchema7 } from 'json-schema';+import { type RestrictedFieldsPermissions } from 'twenty-shared/types';+import {+ isDefined,+ shouldExcludeFieldFromAgentToolSchema,+} from 'twenty-shared/utils';++import { generateFieldFilterJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/field-filters.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';+import { referenceJsonSchemaDefinition } from 'src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util';+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';++const RECORD_FILTER_NAME = 'RecordFilter';++const RECORD_FILTER_REFERENCE: JSONSchema7 = {+ $ref: `#/$defs/${RECORD_FILTER_NAME}`,+};++const LOGICAL_FILTER_PROPERTIES: Record<string, JSONSchema7> = {+ or: {+ description: 'OR condition - matches if ANY of the filters match',+ type: 'array',+ items: RECORD_FILTER_REFERENCE,+ },+ and: {+ description: 'AND condition - matches if ALL filters match',+ type: 'array',+ items: RECORD_FILTER_REFERENCE,+ },+ not: {+ description: 'NOT condition - matches if the filter does NOT match',+ ...RECORD_FILTER_REFERENCE,+ },+};++export const generateRecordFilterJsonSchema = ({+ objectMetadata,+ restrictedFields,+ definitions,+ additionalExcludedFieldNames = [],+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+ definitions: JsonSchemaDefinitions;+ additionalExcludedFieldNames?: string[];+}): { properties: Record<string, JSONSchema7>; reference: JSONSchema7 } => {+ const properties: Record<string, JSONSchema7> = {};++ for (const field of objectMetadata.fields) {+ if (+ shouldExcludeFieldFromAgentToolSchema({+ fieldName: field.name,+ isSystem: field.isSystem,+ additionalExcludedFieldNames,+ }) ||+ restrictedFields?.[field.id]?.canRead === false+ ) {+ continue;+ }++ const fieldFilter = generateFieldFilterJsonSchema({ field, definitions });++ if (!isDefined(fieldFilter)) {+ continue;+ }++ const propertyName = isMorphOrRelationFlatFieldMetadata(field)+ ? computeMorphOrRelationFieldJoinColumnName({ name: field.name })+ : field.name;++ properties[propertyName] = fieldFilter;+ }++ Object.assign(properties, LOGICAL_FILTER_PROPERTIES);++ const reference = referenceJsonSchemaDefinition({+ definitions,+ name: RECORD_FILTER_NAME,+ schema: { type: 'object', properties },+ });++ return { properties, reference };+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema.tsnew file mode 100644index 00000000000..1bac1c798a9--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema.ts@@ -0,0 +1,213 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type JSONSchema7 } from 'json-schema';+import {+ FieldMetadataType,+ NumberDataType,+ type RestrictedFieldsPermissions,+} from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { filesFieldSchema } from 'src/engine/api/common/common-args-processors/data-arg-processor/validator-utils/validate-files-field-or-throw.util';+import { SHARED_VALUE_JSON_SCHEMAS } from 'src/engine/core-modules/record-crud/json-schemas/shared-value-definitions.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';+import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';+import { getFieldOptionValues } from 'src/engine/core-modules/record-crud/utils/get-field-option-values.util';+import { referenceJsonSchemaDefinition } from 'src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util';+import { toToolJsonSchema } from 'src/engine/core-modules/record-crud/utils/to-tool-json-schema.util';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';+import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';++type SharedValueName = keyof typeof SHARED_VALUE_JSON_SCHEMAS;++const SYSTEM_MANAGED_FIELD_NAMES = new Set([+ 'id',+ 'createdAt',+ 'updatedAt',+ 'deletedAt',+ 'createdBy',+ 'updatedBy',+]);++const SHARED_VALUE_NAME_BY_FIELD_TYPE: Partial<+ Record<FieldMetadataType, SharedValueName>+> = {+ [FieldMetadataType.UUID]: 'UuidValue',+ [FieldMetadataType.LINKS]: 'LinksValue',+ [FieldMetadataType.CURRENCY]: 'CurrencyValue',+ [FieldMetadataType.FULL_NAME]: 'FullNameValue',+ [FieldMetadataType.ADDRESS]: 'AddressValue',+ [FieldMetadataType.EMAILS]: 'EmailsValue',+ [FieldMetadataType.PHONES]: 'PhonesValue',+ [FieldMetadataType.RICH_TEXT]: 'RichTextValue',+};++const ACTOR_SOURCES = [+ 'EMAIL',+ 'CALENDAR',+ 'WORKFLOW',+ 'AGENT',+ 'API',+ 'IMPORT',+ 'MANUAL',+ 'SYSTEM',+ 'WEBHOOK',+];++const FILES_JSON_SCHEMA = toToolJsonSchema(filesFieldSchema);++const POSITION_JSON_SCHEMA: JSONSchema7 = {+ description:+ 'Use "first" to insert at the top, "last" for the bottom, or a number for explicit ordering. Leave empty to place at the top (recommended).',+ anyOf: [+ { type: 'number' },+ { type: 'string', const: 'first' },+ { type: 'string', const: 'last' },+ ],+};++const getOptionsJsonSchema = (field: FlatFieldMetadata): JSONSchema7 => {+ const optionValues = getFieldOptionValues(field);++ return optionValues.length > 0+ ? { type: 'string', enum: optionValues }+ : { type: 'string' };+};++const getFieldValueJsonSchema = ({+ field,+ definitions,+}: {+ field: FlatFieldMetadata;+ definitions: JsonSchemaDefinitions;+}): JSONSchema7 => {+ const sharedValueName = SHARED_VALUE_NAME_BY_FIELD_TYPE[field.type];++ if (isDefined(sharedValueName)) {+ return referenceJsonSchemaDefinition({+ definitions,+ name: sharedValueName,+ schema: SHARED_VALUE_JSON_SCHEMAS[sharedValueName],+ });+ }++ if (isFlatFieldMetadataOfType(field, FieldMetadataType.NUMBER)) {+ const isDecimal =+ field.settings?.dataType === NumberDataType.FLOAT ||+ (field.settings?.decimals ?? 0) > 0;++ return { type: isDecimal ? 'number' : 'integer' };+ }++ switch (field.type) {+ case FieldMetadataType.DATE_TIME:+ return { type: 'string', format: 'date-time' };+ case FieldMetadataType.DATE:+ return { type: 'string', format: 'date' };+ case FieldMetadataType.NUMERIC:+ case FieldMetadataType.POSITION:+ return { type: 'number' };+ case FieldMetadataType.BOOLEAN:+ return { type: 'boolean' };+ case FieldMetadataType.RAW_JSON:+ return {+ type: 'object',+ propertyNames: { type: 'string' },+ additionalProperties: {},+ };+ case FieldMetadataType.SELECT:+ case FieldMetadataType.RATING:+ return getOptionsJsonSchema(field);+ case FieldMetadataType.MULTI_SELECT:+ return { type: 'array', items: getOptionsJsonSchema(field) };+ case FieldMetadataType.ARRAY:+ return { type: 'array', items: { type: 'string' } };+ case FieldMetadataType.ACTOR:+ return {+ type: 'object',+ properties: { source: { type: 'string', enum: ACTOR_SOURCES } },+ };+ case FieldMetadataType.FILES:+ return FILES_JSON_SCHEMA;+ default:+ return { type: 'string' };+ }+};++const getPropertyJsonSchema = ({+ field,+ definitions,+}: {+ field: FlatFieldMetadata;+ definitions: JsonSchemaDefinitions;+}): JSONSchema7 => {+ if (field.name === 'position') {+ return POSITION_JSON_SCHEMA;+ }++ return {+ ...(isNonEmptyString(field.description) && {+ description: field.description,+ }),+ ...getFieldValueJsonSchema({ field, definitions }),+ };+};++export const generateRecordPropertiesJsonSchema = ({+ objectMetadata,+ restrictedFields,+ definitions,+ isPartial = false,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+ definitions: JsonSchemaDefinitions;+ isPartial?: boolean;+}): { properties: Record<string, JSONSchema7>; required: string[] } => {+ const properties: Record<string, JSONSchema7> = {};+ const required: string[] = [];++ for (const field of objectMetadata.fields) {+ if (+ SYSTEM_MANAGED_FIELD_NAMES.has(field.name) ||+ field.type === FieldMetadataType.TS_VECTOR ||+ restrictedFields?.[field.id]?.canUpdate === false+ ) {+ continue;+ }++ const isRequired = !field.isNullable && !isPartial;++ if (isMorphOrRelationFlatFieldMetadata(field)) {+ if (!isManyToOneFlatFieldMetadata(field)) {+ continue;+ }++ const joinColumnName = computeMorphOrRelationFieldJoinColumnName({+ name: field.name,+ });++ properties[joinColumnName] = referenceJsonSchemaDefinition({+ definitions,+ name: 'UuidValue',+ schema: SHARED_VALUE_JSON_SCHEMAS.UuidValue,+ });++ if (isRequired) {+ required.push(joinColumnName);+ }++ continue;+ }++ properties[field.name] = getPropertyJsonSchema({ field, definitions });++ if (isRequired) {+ required.push(field.name);+ }+ }++ return { properties, required };+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/shared-filter-definitions.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/shared-filter-definitions.json-schema.tsnew file mode 100644index 00000000000..070151683ad--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/shared-filter-definitions.json-schema.ts@@ -0,0 +1,181 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type JSONSchema7 } from 'json-schema';++const NULL_CHECK_REFERENCE: JSONSchema7 = { $ref: '#/$defs/NullCheck' };++const stringOperator = ({+ description,+ format,+}: {+ description: string;+ format?: string;+}): JSONSchema7 => ({+ description,+ type: 'string',+ ...(isNonEmptyString(format) && { format }),+});++const numberOperator = (description: string): JSONSchema7 => ({+ description,+ type: 'number',+});++const inOperator = ({+ items,+ description = 'In array',+}: {+ items: JSONSchema7;+ description?: string;+}): JSONSchema7 => ({ description, type: 'array', items });++const textFilter = ({+ format,+ hasAffixOperators = false,+ hasInOperator = false,+}: {+ format?: string;+ hasAffixOperators?: boolean;+ hasInOperator?: boolean;+} = {}): JSONSchema7 => ({+ type: 'object',+ properties: {+ eq: stringOperator({ description: 'Equals', format }),+ neq: stringOperator({ description: 'Not equals', format }),+ ...(hasInOperator && { in: inOperator({ items: { type: 'string' } }) }),+ like: stringOperator({ description: 'LIKE (% wildcard)' }),+ ilike: stringOperator({+ description: 'ILIKE (% wildcard, case-insensitive)',+ }),+ ...(hasAffixOperators && {+ startsWith: stringOperator({ description: 'Starts with' }),+ endsWith: stringOperator({ description: 'Ends with' }),+ }),+ is: NULL_CHECK_REFERENCE,+ },+});++const NUMBER_FILTER: JSONSchema7 = {+ type: 'object',+ properties: {+ eq: numberOperator('Equals'),+ neq: numberOperator('Not equals'),+ gt: numberOperator('>'),+ gte: numberOperator('>='),+ lt: numberOperator('<'),+ lte: numberOperator('<='),+ in: inOperator({ items: { type: 'number' } }),+ is: NULL_CHECK_REFERENCE,+ },+};++const dateTimeOperator = (description: string): JSONSchema7 =>+ stringOperator({ description, format: 'date-time' });++const uuidOperator = (description: string): JSONSchema7 =>+ stringOperator({ description, format: 'uuid' });++export const SHARED_FILTER_JSON_SCHEMAS = {+ NullCheck: {+ description: 'Is null or not null',+ type: 'string',+ enum: ['NULL', 'NOT_NULL'],+ },+ TextFilter: textFilter({ hasAffixOperators: true, hasInOperator: true }),+ NumberFilter: NUMBER_FILTER,+ DateFilter: {+ type: 'object',+ properties: {+ eq: dateTimeOperator('Equals (ISO datetime)'),+ neq: dateTimeOperator('Not equals (ISO datetime)'),+ gt: dateTimeOperator('> ISO datetime'),+ gte: dateTimeOperator('>= ISO datetime'),+ lt: dateTimeOperator('< ISO datetime'),+ lte: dateTimeOperator('<= ISO datetime'),+ in: inOperator({+ items: { type: 'string', format: 'date-time' },+ description: 'In array (ISO datetimes)',+ }),+ is: NULL_CHECK_REFERENCE,+ },+ },+ BooleanFilter: {+ type: 'object',+ properties: {+ eq: { description: 'Equals', type: 'boolean' },+ is: NULL_CHECK_REFERENCE,+ },+ },+ UuidFilter: {+ type: 'object',+ properties: {+ eq: uuidOperator('Equals'),+ neq: uuidOperator('Not equals'),+ in: inOperator({+ items: { type: 'string', format: 'uuid' },+ description: 'In array of values',+ }),+ is: NULL_CHECK_REFERENCE,+ },+ },+ DefaultFilter: textFilter(),+ ArrayFilter: {+ type: 'object',+ properties: {+ containsIlike: stringOperator({+ description: 'Contains case-insensitive substring',+ }),+ is: NULL_CHECK_REFERENCE,+ isEmptyArray: { description: 'Is empty array', type: 'boolean' },+ },+ },+ LinksFilter: {+ type: 'object',+ properties: { primaryLinkUrl: textFilter({ format: 'uri' }) },+ },+ AddressFilter: {+ type: 'object',+ properties: {+ addressStreet1: textFilter(),+ addressCity: textFilter(),+ addressCountry: textFilter(),+ },+ },+ FullNameFilter: {+ type: 'object',+ properties: {+ firstName: textFilter({ hasAffixOperators: true }),+ lastName: textFilter({ hasAffixOperators: true }),+ },+ },+ EmailsFilter: {+ type: 'object',+ properties: { primaryEmail: textFilter({ format: 'email' }) },+ },+ PhonesFilter: {+ type: 'object',+ properties: { primaryPhoneNumber: textFilter() },+ },+ RichTextFilter: {+ type: 'object',+ properties: { markdown: textFilter({ hasAffixOperators: true }) },+ },+ CurrencyFilter: {+ type: 'object',+ properties: {+ amountMicros: {+ description:+ 'Currency amount in micros (1 unit = 1,000,000 micros). Multiply the user-provided amount by 1,000,000 to build this filter.',+ ...NUMBER_FILTER,+ },+ currencyCode: {+ type: 'object',+ properties: {+ eq: stringOperator({ description: 'Equals' }),+ neq: stringOperator({ description: 'Not equals' }),+ in: inOperator({ items: { type: 'string' } }),+ is: NULL_CHECK_REFERENCE,+ },+ },+ },+ },+} satisfies Record<string, JSONSchema7>;diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/shared-value-definitions.json-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/shared-value-definitions.json-schema.tsnew file mode 100644index 00000000000..3860b3493ab--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/json-schemas/shared-value-definitions.json-schema.ts@@ -0,0 +1,88 @@+import { type JSONSchema7 } from 'json-schema';++const STRING: JSONSchema7 = { type: 'string' };+const NUMBER: JSONSchema7 = { type: 'number' };++export const SHARED_VALUE_JSON_SCHEMAS = {+ UuidValue: { type: 'string', format: 'uuid' },+ LinksValue: {+ type: 'object',+ properties: {+ primaryLinkLabel: STRING,+ primaryLinkUrl: { type: 'string', format: 'uri' },+ secondaryLinks: {+ type: 'array',+ items: {+ type: 'object',+ properties: {+ url: { type: 'string', format: 'uri' },+ label: STRING,+ },+ required: ['url', 'label'],+ },+ },+ },+ },+ CurrencyValue: {+ type: 'object',+ properties: {+ amountMicros: {+ description:+ 'Currency amount in micros (1 unit = 1,000,000 micros). Multiply the user-provided amount by 1,000,000 before writing.',+ type: 'number',+ },+ currencyCode: STRING,+ },+ },+ FullNameValue: {+ type: 'object',+ properties: { firstName: STRING, lastName: STRING },+ },+ AddressValue: {+ type: 'object',+ properties: {+ addressStreet1: STRING,+ addressStreet2: STRING,+ addressCity: STRING,+ addressPostcode: STRING,+ addressState: STRING,+ addressCountry: STRING,+ addressLat: NUMBER,+ addressLng: NUMBER,+ },+ },+ EmailsValue: {+ type: 'object',+ properties: {+ primaryEmail: { type: 'string', format: 'email' },+ additionalEmails: {+ type: 'array',+ items: { type: 'string', format: 'email' },+ },+ },+ },+ PhonesValue: {+ type: 'object',+ properties: {+ primaryPhoneNumber: STRING,+ primaryPhoneCountryCode: STRING,+ primaryPhoneCallingCode: STRING,+ additionalPhones: {+ type: 'array',+ items: {+ type: 'object',+ properties: {+ number: STRING,+ countryCode: STRING,+ callingCode: STRING,+ },+ required: ['number'],+ },+ },+ },+ },+ RichTextValue: {+ type: 'object',+ properties: { markdown: STRING, blocknote: STRING },+ },+} satisfies Record<string, JSONSchema7>;diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/types/json-schema-definitions.type.ts b/packages/twenty-server/src/engine/core-modules/record-crud/types/json-schema-definitions.type.tsnew file mode 100644index 00000000000..78d54ab65fc--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/types/json-schema-definitions.type.ts@@ -0,0 +1,3 @@+import { type JSONSchema7 } from 'json-schema';++export type JsonSchemaDefinitions = Record<string, JSONSchema7>;diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-object-json-schema.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-object-json-schema.util.tsnew file mode 100644index 00000000000..7822c0666dc--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/build-object-json-schema.util.ts@@ -0,0 +1,21 @@+import { type JSONSchema7 } from 'json-schema';++import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';++export const buildObjectJsonSchema = ({+ properties,+ required = [],+ definitions = {},+ isStrict = false,+}: {+ properties: Record<string, JSONSchema7>;+ required?: string[];+ definitions?: JsonSchemaDefinitions;+ isStrict?: boolean;+}): JSONSchema7 => ({+ type: 'object',+ properties,+ ...(required.length > 0 && { required }),+ ...(isStrict && { additionalProperties: false }),+ ...(Object.keys(definitions).length > 0 && { $defs: definitions }),+});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-many-record-input-schema.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-many-record-input-schema.util.tsindex fcda59ec20e..bf972c76589 100644--- a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-many-record-input-schema.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-many-record-input-schema.util.ts@@ -1,26 +1,38 @@+import { type JSONSchema7 } from 'json-schema';import { type RestrictedFieldsPermissions } from 'twenty-shared/types';-import { z } from 'zod';+import { generateRecordPropertiesJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateRecordPropertiesZodSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';-export const generateCreateManyRecordInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-) => {- const recordSchema = generateRecordPropertiesZodSchema(- objectMetadata,- false,- restrictedFields,- );+export const generateCreateManyRecordInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 => {+ const definitions: JsonSchemaDefinitions = {};- return z.object({- records: z- .array(recordSchema)- .min(1)- .max(20)- .describe(- 'Array of records to create. Each record should contain the required fields. Maximum 20 records per call.',- ),+ return buildObjectJsonSchema({+ properties: {+ records: {+ description:+ 'Array of records to create. Each record should contain the required fields. Maximum 20 records per call.',+ minItems: 1,+ maxItems: 20,+ type: 'array',+ items: buildObjectJsonSchema(+ generateRecordPropertiesJsonSchema({+ objectMetadata,+ restrictedFields,+ definitions,+ }),+ ),+ },+ },+ required: ['records'],+ definitions,});};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-record-input-schema.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-record-input-schema.util.tsindex a30a47a8358..9f9853ab3fa 100644--- a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-record-input-schema.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-create-record-input-schema.util.ts@@ -1,15 +1,26 @@+import { type JSONSchema7 } from 'json-schema';import { type RestrictedFieldsPermissions } from 'twenty-shared/types';+import { generateRecordPropertiesJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateRecordPropertiesZodSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';-export const generateCreateRecordInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-) => {- return generateRecordPropertiesZodSchema(- objectMetadata,- false,- restrictedFields,- );+export const generateCreateRecordInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 => {+ const definitions: JsonSchemaDefinitions = {};++ return buildObjectJsonSchema({+ ...generateRecordPropertiesJsonSchema({+ objectMetadata,+ restrictedFields,+ definitions,+ }),+ definitions,+ });};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-many-record-input-schema.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-many-record-input-schema.util.tsindex 3138b02ed0a..c68654f88c6 100644--- a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-many-record-input-schema.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-many-record-input-schema.util.ts@@ -1,32 +1,49 @@+import { type JSONSchema7 } from 'json-schema';import { type RestrictedFieldsPermissions } from 'twenty-shared/types';-import { z } from 'zod';+import { generateRecordFilterJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-filter.json-schema';+import { generateRecordPropertiesJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateRecordFilterSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema';-import { generateRecordPropertiesZodSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';-export const generateUpdateManyRecordInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-) => {- const { filterSchema } = generateRecordFilterSchema({+export const generateUpdateManyRecordInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 => {+ const definitions: JsonSchemaDefinitions = {};++ const { reference: filterReference } = generateRecordFilterJsonSchema({objectMetadata,restrictedFields,+ definitions,additionalExcludedFieldNames: ['createdAt', 'updatedAt'],});- const dataSchema = generateRecordPropertiesZodSchema(+ const { properties } = generateRecordPropertiesJsonSchema({objectMetadata,- false,restrictedFields,- ).partial();+ definitions,+ isPartial: true,+ });- return z.object({- filter: filterSchema.describe(- 'Filter to select which records to update. Supports field-level filters and logical operators (or, and, not). WARNING: A broad filter may update many records at once. Always verify the filter scope with a find query first.',- ),- data: dataSchema.describe(- 'The field values to apply to all matching records. Only include fields you want to change.',- ),+ return buildObjectJsonSchema({+ properties: {+ filter: {+ description:+ 'Filter to select which records to update. Supports field-level filters and logical operators (or, and, not). WARNING: A broad filter may update many records at once. Always verify the filter scope with a find query first.',+ ...filterReference,+ },+ data: {+ description:+ 'The field values to apply to all matching records. Only include fields you want to change.',+ ...buildObjectJsonSchema({ properties }),+ },+ },+ required: ['filter', 'data'],+ definitions,});};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-record-input-schema.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-record-input-schema.util.tsindex 4d08095da49..823c3ccc8c8 100644--- a/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-record-input-schema.util.ts+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/generate-update-record-input-schema.util.ts@@ -1,23 +1,30 @@+import { type JSONSchema7 } from 'json-schema';import { type RestrictedFieldsPermissions } from 'twenty-shared/types';-import { z } from 'zod';+import { generateRecordPropertiesJsonSchema } from 'src/engine/core-modules/record-crud/json-schemas/record-properties.json-schema';+import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateRecordPropertiesZodSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema';+import { buildObjectJsonSchema } from 'src/engine/core-modules/record-crud/utils/build-object-json-schema.util';-export const generateUpdateRecordInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-) => {- const recordPropertiesSchema = generateRecordPropertiesZodSchema(+export const generateUpdateRecordInputSchema = ({+ objectMetadata,+ restrictedFields,+}: {+ objectMetadata: Pick<ObjectMetadataForToolSchema, 'fields'>;+ restrictedFields?: RestrictedFieldsPermissions;+}): JSONSchema7 => {+ const definitions: JsonSchemaDefinitions = {};++ const { properties } = generateRecordPropertiesJsonSchema({objectMetadata,- false,restrictedFields,- );+ definitions,+ isPartial: true,+ });- return recordPropertiesSchema.partial().extend({- id: z.string().uuid({- message:- 'The unique identifier (UUID) of the record to update. This is required to identify which record should be modified.',- }),+ return buildObjectJsonSchema({+ properties: { ...properties, id: { type: 'string', format: 'uuid' } },+ required: ['id'],+ definitions,});};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/get-field-option-values.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/get-field-option-values.util.tsnew file mode 100644index 00000000000..dda90a4e347--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/get-field-option-values.util.ts@@ -0,0 +1,5 @@+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';++export const getFieldOptionValues = (+ field: Pick<FlatFieldMetadata, 'options'>,+): string[] => field.options?.map((option) => option.value) ?? [];diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util.ts b/packages/twenty-server/src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util.tsnew file mode 100644index 00000000000..ca92277b86d--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/record-crud/utils/reference-json-schema-definition.util.ts@@ -0,0 +1,17 @@+import { type JSONSchema7 } from 'json-schema';++import { type JsonSchemaDefinitions } from 'src/engine/core-modules/record-crud/types/json-schema-definitions.type';++export const referenceJsonSchemaDefinition = ({+ definitions,+ name,+ schema,+}: {+ definitions: JsonSchemaDefinitions;+ name: string;+ schema: JSONSchema7;+}): JSONSchema7 => {+ definitions[name] = schema;++ return { $ref: `#/$defs/${name}` };+};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/field-filters.zod-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/field-filters.zod-schema.spec.tsdeleted file mode 100644index 3cac0557c2c..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/field-filters.zod-schema.spec.ts+++ /dev/null@@ -1,72 +0,0 @@-import { FieldMetadataType } from 'twenty-shared/types';--import { generateFieldFilterZodSchema } from 'src/engine/core-modules/record-crud/zod-schemas/field-filters.zod-schema';-import { type FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';-import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';--const fieldOfType = (- type: FieldMetadataType,- name = 'body',- settings?: Record<string, unknown>,-) => ({ type, name, settings }) as FieldMetadataEntity;--describe('generateFieldFilterZodSchema', () => {- describe('TEXT', () => {- it('exposes scalar pattern operators at the field root', () => {- const schema = generateFieldFilterZodSchema(- fieldOfType(FieldMetadataType.TEXT),- );-- expect(schema).not.toBeNull();- expect(schema!.parse({ ilike: '%foo%' })).toEqual({ ilike: '%foo%' });- });- });-- describe('RICH_TEXT', () => {- // Regression for the AI find-records bug: RICH_TEXT is a composite- // (`markdown` / `blocknote` sub-fields). Advertising root-level scalar- // operators made the agent emit `{ ilike }`, which the query layer rejects- // with `Sub field "ilike" not found for composite type: RICH_TEXT`.- it('routes pattern operators onto the markdown sub-field', () => {- const schema = generateFieldFilterZodSchema(- fieldOfType(FieldMetadataType.RICH_TEXT),- );-- expect(schema).not.toBeNull();- expect(schema!.parse({ markdown: { ilike: '%hello%' } })).toEqual({- markdown: { ilike: '%hello%' },- });- });-- it('no longer accepts scalar operators at the composite root', () => {- const schema = generateFieldFilterZodSchema(- fieldOfType(FieldMetadataType.RICH_TEXT),- );-- // Root-level operators are stripped (unknown keys), so the malformed- // `{ ilike }` filter never reaches the query runner.- expect(schema!.parse({ ilike: '%hello%' })).toEqual({});- });- });-- describe('MORPH_RELATION', () => {- // Regression: morph relations (e.g. noteTarget.targetPerson) are filtered- // by their join column (`${name}Id`). Without a dedicated case they hit the- // text default and advertise like/ilike, which the runner rejects when it- // resolves the relation (`Object person doesn't have any "ilike" field`).- const uuid = '7def8b6a-ec89-48f1-9835-ec2f7c726ef0';-- it('filters by the related record id and rejects text operators', () => {- const schema = generateFieldFilterZodSchema(- fieldOfType(FieldMetadataType.MORPH_RELATION, 'targetPerson', {- relationType: RelationType.MANY_TO_ONE,- }),- );-- expect(schema).not.toBeNull();- expect(schema!.parse({ eq: uuid })).toEqual({ eq: uuid });- // `ilike` is not a valid operator for a relation id — stripped.- expect(schema!.parse({ ilike: '%Tom%' })).toEqual({});- });- });-});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/find-tool.zod-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/find-tool.zod-schema.spec.tsdeleted file mode 100644index 944ac3eec3d..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/find-tool.zod-schema.spec.ts+++ /dev/null@@ -1,125 +0,0 @@-import { FieldMetadataType, RelationType } from 'twenty-shared/types';--import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { toToolJsonSchema } from 'src/engine/core-modules/record-crud/utils/to-tool-json-schema.util';-import { generateFindToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/find-tool.zod-schema';--const buildCompanyLikeObjectMetadata = (): ObjectMetadataForToolSchema => {- return {- fields: [- {- id: 'field-id-name',- name: 'name',- type: FieldMetadataType.TEXT,- isSystem: false,- },- {- id: 'field-id-address',- name: 'address',- type: FieldMetadataType.ADDRESS,- isSystem: false,- },- {- id: 'field-id-account-owner',- name: 'accountOwner',- type: FieldMetadataType.RELATION,- isSystem: false,- settings: { relationType: RelationType.MANY_TO_ONE },- },- {- id: 'field-id-created-at',- name: 'createdAt',- type: FieldMetadataType.DATE_TIME,- isSystem: true,- },- {- id: 'field-id-deleted-at',- name: 'deletedAt',- type: FieldMetadataType.DATE_TIME,- isSystem: true,- },- {- id: 'field-id-people',- name: 'people',- type: FieldMetadataType.RELATION,- isSystem: false,- settings: { relationType: RelationType.ONE_TO_MANY },- },- ],- } as unknown as ObjectMetadataForToolSchema;-};--const parseOrderBy = (orderBy: unknown, restrictedFields = {}) =>- generateFindToolInputSchema(- buildCompanyLikeObjectMetadata(),- restrictedFields,- ).safeParse({ select: ['*'], orderBy });--describe('generateFindToolInputSchema orderBy', () => {- it.each([- [[{ name: 'AscNullsFirst' }]],- [[{ address: { addressCity: 'DescNullsLast' } }]],- [[{ accountOwnerId: 'AscNullsLast' }]],- [[{ createdAt: 'DescNullsLast' }]],- [- [- { name: 'DescNullsLast' },- { address: { addressCountry: 'AscNullsFirst' } },- ],- ],- ])('accepts %j', (orderBy) => {- expect(parseOrderBy(orderBy).success).toBe(true);- });-- it.each([- [[{ name: { firstName: 'AscNullsFirst' } }]],- [[{ address: 'AscNullsFirst' }]],- [[{ address: { unknownSubField: 'AscNullsFirst' } }]],- [[{ people: 'AscNullsFirst' }]],- [[{ unknownField: 'AscNullsFirst' }]],- [[{ deletedAt: 'AscNullsFirst' }]],- [[{ name: 'AscNullsFirst', address: { addressCity: 'AscNullsFirst' } }]],- [[{ 'name.firstName': 'AscNullsFirst' }]],- ])('rejects %j', (orderBy) => {- expect(parseOrderBy(orderBy).success).toBe(false);- });-- it('does not offer sorting on unreadable fields', () => {- expect(- parseOrderBy([{ name: 'AscNullsFirst' }], {- 'field-id-name': { canRead: false },- }).success,- ).toBe(false);- });-- it('advertises a direction for scalar fields and sub-fields for composite fields', () => {- type JsonSchemaNode = {- $ref?: string;- enum?: string[];- properties?: Record<string, JsonSchemaNode>;- items?: JsonSchemaNode;- };-- const jsonSchema = toToolJsonSchema(- generateFindToolInputSchema(buildCompanyLikeObjectMetadata()),- ) as JsonSchemaNode & { $defs: Record<string, JsonSchemaNode> };-- const resolve = (node: JsonSchemaNode | undefined) =>- node?.$ref ? jsonSchema.$defs[node.$ref.replace('#/$defs/', '')] : node;-- const orderByItemProperties =- jsonSchema.properties?.orderBy.items?.properties ?? {};-- expect(resolve(orderByItemProperties.name)?.enum).toContain(- 'AscNullsFirst',- );- expect(resolve(orderByItemProperties.name)?.properties).toBeUndefined();- expect(- Object.keys(resolve(orderByItemProperties.address)?.properties ?? {}),- ).toEqual(expect.arrayContaining(['addressCity', 'addressCountry']));- expect(resolve(orderByItemProperties.accountOwnerId)?.enum).toContain(- 'DescNullsLast',- );- expect(orderByItemProperties.people).toBeUndefined();- });-});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/group-by-tool.zod-schema.spec.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/group-by-tool.zod-schema.spec.tsdeleted file mode 100644index 6f68f3804a8..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/__tests__/group-by-tool.zod-schema.spec.ts+++ /dev/null@@ -1,175 +0,0 @@-import { FieldMetadataType } from 'twenty-shared/types';--import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { toToolJsonSchema } from 'src/engine/core-modules/record-crud/utils/to-tool-json-schema.util';-import { generateGroupByToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/group-by-tool.zod-schema';--const buildObjectMetadata = (): ObjectMetadataForToolSchema => {- return {- fields: [- {- id: 'field-id-tags',- name: 'tags',- type: FieldMetadataType.MULTI_SELECT,- isSystem: false,- options: [{ value: 'RADIUS' }, { value: 'PAM' }],- },- {- id: 'field-id-aliases',- name: 'aliases',- type: FieldMetadataType.ARRAY,- isSystem: false,- },- {- id: 'field-id-name',- name: 'name',- type: FieldMetadataType.TEXT,- isSystem: false,- },- ],- } as unknown as ObjectMetadataForToolSchema;-};--describe('generateGroupByToolInputSchema multi-value unnest', () => {- it.each(['tags', 'aliases'])(- 'accepts whole-array grouping on %s',- (fieldName) => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata());-- expect(schema).not.toBeNull();- expect(schema!.parse({ groupBy: [{ [fieldName]: true }] })).toMatchObject(- {- groupBy: [{ [fieldName]: true }],- },- );- },- );-- it.each(['tags', 'aliases'])(- 'accepts the unnest opt-in on %s',- (fieldName) => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata());-- expect(schema).not.toBeNull();- expect(- schema!.parse({ groupBy: [{ [fieldName]: { unnest: true } }] }),- ).toMatchObject({- groupBy: [{ [fieldName]: { unnest: true } }],- });- },- );-- it('accepts unnest together with a second grouping dimension', () => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata());-- expect(- schema!.parse({- groupBy: [{ tags: { unnest: true } }, { name: true }],- }),- ).toMatchObject({- groupBy: [{ tags: { unnest: true } }, { name: true }],- });- });-- it.each([{ unnest: false }, { unnest: true, extra: true }])(- 'rejects an invalid advertised unnest shape: %j',- (definition) => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata());-- expect(- schema!.safeParse({ groupBy: [{ tags: definition }] }).success,- ).toBe(false);- },- );-- it('omits unreadable fields from the advertised grouping choices', () => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata(), {- 'field-id-tags': { canRead: false },- });-- expect(schema).not.toBeNull();- expect(toToolJsonSchema(schema!)).toMatchObject({- properties: {- groupBy: {- items: {- anyOf: expect.not.arrayContaining([- expect.objectContaining({- properties: { tags: expect.anything() },- }),- ]),- },- },- },- });- });-- it.each(['tags', 'aliases'])(- 'publishes whole-array and strict unnest shapes for %s',- (fieldName) => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata());-- expect(schema).not.toBeNull();- expect(toToolJsonSchema(schema!)).toMatchObject({- properties: {- groupBy: {- items: {- anyOf: expect.arrayContaining([- expect.objectContaining({- properties: {- [fieldName]: {- anyOf: expect.arrayContaining([- expect.objectContaining({- type: 'boolean',- const: true,- }),- expect.objectContaining({- type: 'object',- properties: {- unnest: { type: 'boolean', const: true },- },- required: ['unnest'],- additionalProperties: false,- }),- ]),- },- },- }),- ]),- },- },- },- });- },- );-- it('describes the single-unnest rule and overlapping group counts', () => {- const schema = generateGroupByToolInputSchema(buildObjectMetadata());- const jsonSchema = toToolJsonSchema(schema!);-- expect(jsonSchema).toMatchObject({- properties: {- groupBy: {- description: expect.stringContaining(- 'At most one entry can use unnest.',- ),- },- },- });- expect(jsonSchema).toMatchObject({- properties: {- groupBy: {- description: expect.stringContaining(- 'totals can exceed the record count',- ),- },- },- });- expect(jsonSchema).toMatchObject({- properties: {- groupBy: {- description: expect.stringContaining('aliases (multi-value,'),- },- },- });- });-});diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/bulk-delete-tool.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/bulk-delete-tool.zod-schema.tsdeleted file mode 100644index 015d9cdf367..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/bulk-delete-tool.zod-schema.ts+++ /dev/null@@ -1,25 +0,0 @@-import { type RestrictedFieldsPermissions } from 'twenty-shared/types';-import { z } from 'zod';--import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateRecordFilterSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema';--export const generateBulkDeleteToolInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-) => {- const { filterSchema } = generateRecordFilterSchema({- objectMetadata,- restrictedFields,- });-- return z.object({- filter: filterSchema.describe(- 'Filter to select which records to delete. Supports field-level filters and logical operators (or, and, not). WARNING: A broad filter may delete many records at once. Always verify the filter scope with a find query first.',- ),- });-};--export type BulkDeleteToolInput = {- filter: Record<string, unknown>;-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/delete-tool.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/delete-tool.zod-schema.tsdeleted file mode 100644index 406af2cd2c7..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/delete-tool.zod-schema.ts+++ /dev/null@@ -1,7 +0,0 @@-import { z } from 'zod';--export const DeleteToolInputSchema = z.object({- id: z.string().uuid().describe('The unique UUID of the record to delete'),-});--export type DeleteToolInput = z.infer<typeof DeleteToolInputSchema>;diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/field-filters.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/field-filters.zod-schema.tsdeleted file mode 100644index 2591aa65fe2..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/field-filters.zod-schema.ts+++ /dev/null@@ -1,158 +0,0 @@-import { FieldMetadataType } from 'twenty-shared/types';-import { z } from 'zod';--import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';--import {- AddressFilterSchema,- ArrayFieldFilterSchema,- BooleanFilterSchema,- CurrencyFilterSchema,- DateFilterSchema,- DefaultFilterSchema,- EmailsFilterSchema,- FullNameFilterSchema,- LinksFilterSchema,- NullCheckEnum,- NumberFilterSchema,- PhonesFilterSchema,- RichTextFilterSchema,- TextFilterSchema,- UuidFilterSchema,-} from 'src/engine/core-modules/record-crud/zod-schemas/shared-filter-defs.zod-schema';-import { type FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';-import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';-import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';--export { NullCheckEnum };--export const generateFieldFilterZodSchema = (- field: FieldMetadataEntity | FlatFieldMetadata,-): z.ZodTypeAny | null => {- switch (field.type) {- case FieldMetadataType.UUID:- return UuidFilterSchema;-- case FieldMetadataType.TEXT:- return TextFilterSchema;-- case FieldMetadataType.RICH_TEXT:- return RichTextFilterSchema;-- case FieldMetadataType.NUMBER:- case FieldMetadataType.NUMERIC:- case FieldMetadataType.POSITION:- return NumberFilterSchema;-- case FieldMetadataType.BOOLEAN:- return BooleanFilterSchema;-- case FieldMetadataType.DATE_TIME:- case FieldMetadataType.DATE:- return DateFilterSchema;-- case FieldMetadataType.SELECT: {- const enumValues =- field.options?.map((option: { value: string }) => option.value) || [];-- if (enumValues.length === 0) {- return null;- }-- const selectEnum = z.enum(enumValues as [string, ...string[]]);-- return z- .object({- eq: selectEnum.optional().describe('Equals'),- neq: selectEnum.optional().describe('Not equals'),- in: z.array(selectEnum).optional().describe('In array of values'),- is: NullCheckEnum.optional(),- })- .optional();- }-- case FieldMetadataType.MULTI_SELECT: {- const enumValues =- field.options?.map((option: { value: string }) => option.value) || [];-- if (enumValues.length === 0) {- return null;- }-- const multiSelectEnum = z.enum(enumValues as [string, ...string[]]);-- return z- .object({- in: z- .array(multiSelectEnum)- .optional()- .describe('Contains any of these values'),- is: NullCheckEnum.optional(),- isEmptyArray: z.boolean().optional().describe('Is empty array'),- })- .optional();- }-- case FieldMetadataType.RATING: {- const enumValues =- field.options?.map((option: { value: string }) => option.value) || [];-- if (enumValues.length === 0) {- return null;- }-- const ratingEnum = z.enum(enumValues as [string, ...string[]]);-- return z- .object({- eq: ratingEnum.optional().describe('Equals'),- in: z.array(ratingEnum).optional().describe('In array of values'),- is: NullCheckEnum.optional(),- })- .optional();- }-- case FieldMetadataType.ARRAY:- return ArrayFieldFilterSchema;-- case FieldMetadataType.CURRENCY:- return CurrencyFilterSchema;-- case FieldMetadataType.FULL_NAME:- return FullNameFilterSchema;-- case FieldMetadataType.ADDRESS:- return AddressFilterSchema;-- case FieldMetadataType.EMAILS:- return EmailsFilterSchema;-- case FieldMetadataType.PHONES:- return PhonesFilterSchema;-- case FieldMetadataType.LINKS:- return LinksFilterSchema;-- case FieldMetadataType.MORPH_RELATION:- case FieldMetadataType.RELATION:- if (- (isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) ||- isFieldMetadataEntityOfType(- field,- FieldMetadataType.MORPH_RELATION,- )) &&- field.settings?.relationType === RelationType.MANY_TO_ONE- ) {- return UuidFilterSchema;- }-- return null;-- case FieldMetadataType.RAW_JSON:- case FieldMetadataType.FILES:- return DefaultFilterSchema;-- default:- return DefaultFilterSchema;- }-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/find-one-tool.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/find-one-tool.zod-schema.tsdeleted file mode 100644index 6cfb819321c..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/find-one-tool.zod-schema.ts+++ /dev/null@@ -1,17 +0,0 @@-import { z } from 'zod';--export const FindOneToolInputSchema = z.object({- id: z.string().uuid().describe('The unique UUID of the record to retrieve'),- select: z- .array(z.string())- .nonempty()- .describe(- 'Fields to include in the response. Required. ' +- "Use '*' to return all fields. " +- 'Relation fields resolve to related records as {id, label} summaries: ' +- 'MANY_TO_ONE returns a single object (or select the <name>Id FK column for just the id), ' +- 'ONE_TO_MANY returns up to 60 related records.',- ),-});--export type FindOneToolInput = z.infer<typeof FindOneToolInputSchema>;diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/find-tool.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/find-tool.zod-schema.tsdeleted file mode 100644index b85e737cfe3..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/find-tool.zod-schema.ts+++ /dev/null@@ -1,57 +0,0 @@-import { type RestrictedFieldsPermissions } from 'twenty-shared/types';-import { z } from 'zod';--import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateRecordOrderBySchema } from 'src/engine/core-modules/record-crud/zod-schemas/order-by.zod-schema';-import { generateRecordFilterSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema';--export const generateFindToolInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-) => {- const { filterShape, filterSchema } = generateRecordFilterSchema({- objectMetadata,- restrictedFields,- });- return z.object({- limit: z- .number()- .int()- .positive()- .max(100)- .default(10)- .describe(- 'Maximum number of records to return (default: 10, max: 100). Start small and increase only if needed.',- ),- offset: z- .number()- .int()- .nonnegative()- .default(0)- .describe('Number of records to skip (default: 0)'),- orderBy: generateRecordOrderBySchema({ objectMetadata, restrictedFields }),- select: z- .array(z.string())- .nonempty()- .describe(- `Fields to include in the response. Required. ` +- `Use '*' to return all fields, or list specific field names. ` +- `Relation fields resolve to related records as {id, label} summaries: ` +- `MANY_TO_ONE returns a single object (or select the '<name>Id' FK column for just the id), ` +- `ONE_TO_MANY returns up to 60 related records. ` +- `For more fields or more records, query the related object directly. `,- ),- ...filterShape,- or: z- .array(filterSchema)- .optional()- .describe('OR condition - matches if ANY of the filters match'),- and: z- .array(filterSchema)- .optional()- .describe('AND condition - matches if ALL filters match'),- not: filterSchema- .optional()- .describe('NOT condition - matches if the filter does NOT match'),- });-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/group-by-tool.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/group-by-tool.zod-schema.tsdeleted file mode 100644index dc97fdfa01b..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/group-by-tool.zod-schema.ts+++ /dev/null@@ -1,285 +0,0 @@-import {- AggregateOperations,- FirstDayOfTheWeek,- FieldMetadataType,- ObjectRecordGroupByDateGranularity,- RelationType,- type RestrictedFieldsPermissions,-} from 'twenty-shared/types';-import {- isFieldMetadataArrayKind,- isFieldMetadataDateKind,- isFieldMetadataSupportedInGroupBy,-} from 'twenty-shared/utils';-import { z } from 'zod';--import { getAvailableAggregationsFromObjectFields } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-available-aggregations-from-object-fields.util';-import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { resolveAggregateFieldKey } from 'src/engine/core-modules/record-crud/utils/resolve-aggregate-field-key.util';-import { generateRecordFilterSchema } from 'src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema';-import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';-import { getGroupableSubFieldsForCompositeType } from 'src/engine/metadata-modules/field-metadata/utils/get-groupable-sub-fields-for-composite-type.util';-import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';--const dateGranularityValues = Object.values(- ObjectRecordGroupByDateGranularity,-).filter((v) => v !== ObjectRecordGroupByDateGranularity.NONE) as [- string,- ...string[],-];--const dateGroupBySchema = z- .object({- granularity: z- .enum(dateGranularityValues)- .default(ObjectRecordGroupByDateGranularity.MONTH)- .describe('Date grouping granularity. Default: MONTH.'),- weekStartDay: z- .nativeEnum(FirstDayOfTheWeek)- .optional()- .describe(- 'First day of week (MONDAY, SUNDAY, SATURDAY). Only used when granularity is WEEK.',- ),- timeZone: z- .string()- .default('UTC')- .describe(- 'IANA timezone for date groupings (e.g. "America/New_York"). Default: UTC.',- ),- })- .strict()- .describe('Date field grouping configuration');--const buildGroupByEntriesAndDescriptions = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-): {- groupByEntries: z.ZodTypeAny[];- fieldNameDescriptions: string[];-} => {- const groupByEntries: z.ZodTypeAny[] = [];- const fieldNameDescriptions: string[] = [];-- for (const field of objectMetadata.fields) {- if (restrictedFields?.[field.id]?.canRead === false) {- continue;- }-- if (!isFieldMetadataSupportedInGroupBy(field)) {- continue;- }-- const isRelationOrMorphRelation =- isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) ||- isFieldMetadataEntityOfType(field, FieldMetadataType.MORPH_RELATION);-- if (isRelationOrMorphRelation) {- if (field.settings?.relationType === RelationType.MANY_TO_ONE) {- const relationFieldName = `${field.name}Id`;-- groupByEntries.push(- z.object({ [relationFieldName]: z.literal(true) }).strict(),- );- fieldNameDescriptions.push(relationFieldName);- }-- continue;- }-- if (isFieldMetadataDateKind(field.type)) {- groupByEntries.push(- z.object({ [field.name]: dateGroupBySchema }).strict(),- );- fieldNameDescriptions.push(`${field.name} (date)`);- continue;- }-- if (isCompositeFieldMetadataType(field.type)) {- const subFields = getGroupableSubFieldsForCompositeType(field.type);-- if (subFields) {- for (const subField of subFields) {- groupByEntries.push(- z- .object({- [field.name]: z- .object({ [subField]: z.literal(true) })- .strict(),- })- .strict(),- );- fieldNameDescriptions.push(`${field.name}.${subField}`);- }- }-- continue;- }-- if (isFieldMetadataArrayKind(field.type)) {- groupByEntries.push(- z- .object({- [field.name]: z.union([- z.literal(true),- z.object({ unnest: z.literal(true) }).strict(),- ]),- })- .strict(),- );- fieldNameDescriptions.push(- `${field.name} (multi-value, {"${field.name}": {"unnest": true}} counts each value)`,- );- continue;- }-- groupByEntries.push(z.object({ [field.name]: z.literal(true) }).strict());- fieldNameDescriptions.push(field.name);- }-- return { groupByEntries, fieldNameDescriptions };-};--export const hasGroupByToolInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-): boolean => {- return (- buildGroupByEntriesAndDescriptions(objectMetadata, restrictedFields)- .groupByEntries.length > 0- );-};--export const generateGroupByToolInputSchema = (- objectMetadata: ObjectMetadataForToolSchema,- restrictedFields?: RestrictedFieldsPermissions,-): z.ZodTypeAny | null => {- const { groupByEntries, fieldNameDescriptions } =- buildGroupByEntriesAndDescriptions(objectMetadata, restrictedFields);-- if (groupByEntries.length === 0) {- return null;- }-- const groupByEntrySchema =- groupByEntries.length === 1- ? groupByEntries[0]- : z.union(- groupByEntries as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]],- );-- const { filterShape, filterSchema } = generateRecordFilterSchema({- objectMetadata,- restrictedFields,- });-- const availableAggregations = getAvailableAggregationsFromObjectFields(- objectMetadata.fields.filter(- (field) => restrictedFields?.[field.id]?.canRead !== false,- ),- );- const availableAggregateFieldNames = Array.from(- new Set(- Object.values(availableAggregations)- .filter(- (aggregation) =>- aggregation.aggregateOperation !== AggregateOperations.COUNT,- )- .map((aggregation) =>- aggregation.subFieldForNumericOperation- ? `${aggregation.fromField}.${aggregation.subFieldForNumericOperation}`- : aggregation.fromField,- ),- ),- );-- return z- .object({- groupBy: z- .array(groupByEntrySchema)- .min(1)- .max(2)- .describe(- `Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: ${fieldNameDescriptions.join(', ')}.`,- ),- aggregateOperation: z- .enum(Object.keys(AggregateOperations) as [string, ...string[]])- .default(AggregateOperations.COUNT)- .describe(- 'Aggregate operation to apply per group. Default: COUNT. Any operation other than COUNT requires aggregateFieldName.',- ),- aggregateFieldName: z- .string()- .optional()- .describe(- `Field to aggregate. Required for any operation other than COUNT. Available fields: ${availableAggregateFieldNames.join(', ')}.`,- ),- limit: z- .number()- .int()- .positive()- .max(100)- .default(50)- .describe(- 'Maximum number of groups to return (default: 50, max: 100).',- ),- orderBy: z- .enum(['ASC', 'DESC'])- .default('DESC')- .describe(- 'Order groups by aggregate value. DESC (default) gives "top N" behavior.',- ),- ...filterShape,- or: z- .array(filterSchema)- .optional()- .describe('OR condition - matches if ANY of the filters match'),- and: z- .array(filterSchema)- .optional()- .describe('AND condition - matches if ALL filters match'),- not: filterSchema- .optional()- .describe('NOT condition - matches if the filter does NOT match'),- })- .strict()- .superRefine((input, context) => {- const aggregateOperation =- input.aggregateOperation as keyof typeof AggregateOperations;-- if (aggregateOperation === AggregateOperations.COUNT) {- if (input.aggregateFieldName) {- context.addIssue({- code: z.ZodIssueCode.custom,- message: 'aggregateFieldName is not supported for COUNT operation.',- path: ['aggregateFieldName'],- });- }-- return;- }-- if (!input.aggregateFieldName) {- context.addIssue({- code: z.ZodIssueCode.custom,- message: `aggregateFieldName is required for ${aggregateOperation} operation.`,- path: ['aggregateFieldName'],- });-- return;- }-- const resolvedAggregateFieldKey = resolveAggregateFieldKey(- aggregateOperation,- input.aggregateFieldName,- availableAggregations,- );-- if (!resolvedAggregateFieldKey) {- context.addIssue({- code: z.ZodIssueCode.custom,- message: `No aggregation available for ${aggregateOperation} on field "${input.aggregateFieldName}".`,- path: ['aggregateFieldName'],- });- }- });-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/order-by.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/order-by.zod-schema.tsdeleted file mode 100644index 13373e4868c..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/order-by.zod-schema.ts+++ /dev/null@@ -1,105 +0,0 @@-import {- compositeTypeDefinitions,- FieldMetadataType,- RelationType,- type RestrictedFieldsPermissions,-} from 'twenty-shared/types';-import {- isDefined,- shouldExcludeFieldFromAgentToolSchema,-} from 'twenty-shared/utils';-import { z } from 'zod';--import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';-import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';--export const OrderByDirectionEnum = z.enum([- 'AscNullsFirst',- 'AscNullsLast',- 'DescNullsFirst',- 'DescNullsLast',-]);--// Mirrors the GraphQL orderBy input, so the shape advertised for each field-// (direction for scalars, sub-fields for composites) is the one the orderBy-// resolver accepts for this object-export const generateRecordOrderBySchema = ({- objectMetadata,- restrictedFields,-}: {- objectMetadata: ObjectMetadataForToolSchema;- restrictedFields?: RestrictedFieldsPermissions;-}): z.ZodTypeAny => {- const orderByItemShape: Record<string, z.ZodTypeAny> = {};-- for (const field of objectMetadata.fields) {- // System fields stay sortable: agents sort by createdAt, updatedAt and- // position to get recent or first records- if (- shouldExcludeFieldFromAgentToolSchema({- fieldName: field.name,- isSystem: false,- excludeId: false,- })- ) {- continue;- }-- if (restrictedFields?.[field.id]?.canRead === false) {- continue;- }-- const isRelationField =- isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) ||- isFieldMetadataEntityOfType(field, FieldMetadataType.MORPH_RELATION);-- if (isRelationField) {- if (field.settings?.relationType === RelationType.MANY_TO_ONE) {- orderByItemShape[`${field.name}Id`] = OrderByDirectionEnum.optional();- }-- continue;- }-- if (isCompositeFieldMetadataType(field.type)) {- const compositeType = compositeTypeDefinitions.get(field.type);-- if (!isDefined(compositeType)) {- continue;- }-- const subFieldShape = Object.fromEntries(- compositeType.properties- .filter((property) => property.hidden !== true)- .map((property) => [property.name, OrderByDirectionEnum.optional()]),- );-- orderByItemShape[field.name] = z- .object(subFieldShape)- .strict()- .optional();-- continue;- }-- orderByItemShape[field.name] = OrderByDirectionEnum.optional();- }-- const orderByItemSchema = z- .object(orderByItemShape)- .strict()- .refine((item) => Object.keys(item).length === 1, {- message: 'Each orderBy item must specify exactly one field',- })- .describe(- 'Object with exactly ONE property. Scalar fields take a direction string; composite fields take an object with one sub-field. Never use dot-notation keys.',- );-- return z- .array(orderByItemSchema)- .optional()- .describe(- 'Array of sort criteria, one field per item. Use "DescNullsLast" for descending (top/largest), "AscNullsFirst" for ascending (bottom/smallest).',- );-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema.tsdeleted file mode 100644index 9c74784f7b5..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/record-filter.zod-schema.ts+++ /dev/null@@ -1,77 +0,0 @@-import {- FieldMetadataType,- RelationType,- type RestrictedFieldsPermissions,-} from 'twenty-shared/types';-import { shouldExcludeFieldFromAgentToolSchema } from 'twenty-shared/utils';-import { z } from 'zod';--import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import { generateFieldFilterZodSchema } from 'src/engine/core-modules/record-crud/zod-schemas/field-filters.zod-schema';-import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';--export const generateRecordFilterSchema = ({- objectMetadata,- restrictedFields,- additionalExcludedFieldNames = [],-}: {- objectMetadata: ObjectMetadataForToolSchema;- restrictedFields?: RestrictedFieldsPermissions;- additionalExcludedFieldNames?: string[];-}): {- filterShape: Record<string, z.ZodTypeAny>;- filterSchema: z.ZodTypeAny;-} => {- const filterShape: Record<string, z.ZodTypeAny> = {};-- objectMetadata.fields.forEach((field) => {- if (- shouldExcludeFieldFromAgentToolSchema({- fieldName: field.name,- isSystem: field.isSystem,- additionalExcludedFieldNames,- })- ) {- return;- }-- if (restrictedFields?.[field.id]?.canRead === false) {- return;- }-- const fieldFilter = generateFieldFilterZodSchema(field);-- if (!fieldFilter) {- return;- }-- const isManyToOneRelationField =- (isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) ||- isFieldMetadataEntityOfType(field, FieldMetadataType.MORPH_RELATION)) &&- field.settings?.relationType === RelationType.MANY_TO_ONE;-- filterShape[isManyToOneRelationField ? `${field.name}Id` : field.name] =- fieldFilter;- });-- const filterSchema: z.ZodTypeAny = z.lazy(() =>- z- .object({- ...filterShape,- or: z- .array(filterSchema)- .optional()- .describe('OR condition - matches if ANY of the filters match'),- and: z- .array(filterSchema)- .optional()- .describe('AND condition - matches if ALL filters match'),- not: filterSchema- .optional()- .describe('NOT condition - matches if the filter does NOT match'),- })- .partial(),- );-- return { filterShape, filterSchema };-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema.tsdeleted file mode 100644index 8ba5588170b..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/record-properties.zod-schema.ts+++ /dev/null@@ -1,317 +0,0 @@-import {- type FieldMetadataSettings,- FieldMetadataType,- NumberDataType,- type RestrictedFieldsPermissions,-} from 'twenty-shared/types';-import { isDefined } from 'twenty-shared/utils';-import { z } from 'zod';--import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';--import { filesFieldSchema } from 'src/engine/api/common/common-args-processors/data-arg-processor/validator-utils/validate-files-field-or-throw.util';-import { type ObjectMetadataForToolSchema } from 'src/engine/core-modules/record-crud/types/object-metadata-for-tool-schema.type';-import {- AddressValueOptionalSchema,- AddressValueSchema,- CurrencyResponseValueOptionalSchema,- CurrencyResponseValueSchema,- CurrencyValueOptionalSchema,- CurrencyValueSchema,- EmailsValueOptionalSchema,- EmailsValueSchema,- FullNameValueOptionalSchema,- FullNameValueSchema,- LinksValueOptionalSchema,- LinksValueSchema,- PhonesValueOptionalSchema,- PhonesValueSchema,- RichTextValueOptionalSchema,- RichTextValueSchema,- UuidValueOptionalSchema,- UuidValueSchema,-} from 'src/engine/core-modules/record-crud/zod-schemas/shared-value-defs.zod-schema';-import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';-import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';--const isFieldAvailable = (field: FlatFieldMetadata, forResponse: boolean) => {- if (forResponse) {- return true;- }- switch (field.name) {- case 'id':- case 'createdAt':- case 'updatedAt':- case 'deletedAt':- case 'createdBy':- case 'updatedBy':- return false;- default:- return true;- }-};--const getFieldZodType = (field: FlatFieldMetadata): z.ZodTypeAny => {- switch (field.type) {- case FieldMetadataType.UUID:- return UuidValueSchema;-- case FieldMetadataType.TEXT:- return z.string();-- case FieldMetadataType.DATE_TIME:- return z.string().datetime();-- case FieldMetadataType.DATE:- return z.string().date();-- case FieldMetadataType.NUMBER: {- const settings =- field.settings as FieldMetadataSettings<FieldMetadataType.NUMBER>;-- if (- settings?.dataType === NumberDataType.FLOAT ||- (isDefined(settings?.decimals) && settings.decimals > 0)- ) {- return z.number();- }-- return z.number().int();- }-- case FieldMetadataType.NUMERIC:- case FieldMetadataType.POSITION:- return z.number();-- case FieldMetadataType.BOOLEAN:- return z.boolean();-- case FieldMetadataType.RAW_JSON:- return z.record(z.string(), z.unknown());-- default:- return z.string();- }-};--export const generateRecordPropertiesZodSchema = (- objectMetadata: ObjectMetadataForToolSchema,- forResponse = false,- restrictedFields?: RestrictedFieldsPermissions,-): z.ZodObject<Record<string, z.ZodTypeAny>> => {- const shape: Record<string, z.ZodTypeAny> = {};-- objectMetadata.fields.forEach((field) => {- if (- !isFieldAvailable(field, forResponse) ||- field.type === FieldMetadataType.TS_VECTOR- ) {- return;- }-- if (restrictedFields?.[field.id]?.canUpdate === false) {- return;- }-- const isRelationOrMorphRelation =- isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) ||- isFieldMetadataEntityOfType(field, FieldMetadataType.MORPH_RELATION);-- if (- isRelationOrMorphRelation &&- field.settings?.relationType === RelationType.MANY_TO_ONE- ) {- shape[`${field.name}Id`] = field.isNullable- ? UuidValueOptionalSchema- : UuidValueSchema;-- return;- }-- if (- isRelationOrMorphRelation &&- field.settings?.relationType === RelationType.ONE_TO_MANY- ) {- return;- }-- let fieldSchema: z.ZodTypeAny;-- switch (field.type) {- case FieldMetadataType.MULTI_SELECT: {- const enumValues =- field.options?.map((option: { value: string }) => option.value) || [];-- if (enumValues.length > 0) {- fieldSchema = z.array(z.enum(enumValues as [string, ...string[]]));- } else {- fieldSchema = z.array(z.string());- }- break;- }-- case FieldMetadataType.SELECT: {- const enumValues =- field.options?.map((option: { value: string }) => option.value) || [];-- if (enumValues.length > 0) {- fieldSchema = z.enum(enumValues as [string, ...string[]]);- } else {- fieldSchema = z.string();- }- break;- }-- case FieldMetadataType.ARRAY:- fieldSchema = z.array(z.string());- break;-- case FieldMetadataType.RATING: {- const enumValues =- field.options?.map((option: { value: string }) => option.value) || [];-- if (enumValues.length > 0) {- fieldSchema = z.enum(enumValues as [string, ...string[]]);- } else {- fieldSchema = z.string();- }- break;- }-- case FieldMetadataType.LINKS: {- const baseSchema = field.isNullable- ? LinksValueOptionalSchema- : LinksValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.CURRENCY: {- const baseSchema = forResponse- ? field.isNullable- ? CurrencyResponseValueOptionalSchema- : CurrencyResponseValueSchema- : field.isNullable- ? CurrencyValueOptionalSchema- : CurrencyValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.FULL_NAME: {- const baseSchema = field.isNullable- ? FullNameValueOptionalSchema- : FullNameValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.ADDRESS: {- const baseSchema = field.isNullable- ? AddressValueOptionalSchema- : AddressValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.ACTOR:- fieldSchema = z.object({- source: z- .enum([- 'EMAIL',- 'CALENDAR',- 'WORKFLOW',- 'AGENT',- 'API',- 'IMPORT',- 'MANUAL',- 'SYSTEM',- 'WEBHOOK',- ])- .optional(),- ...(forResponse- ? {- workspaceMemberId: z.string().uuid().optional(),- name: z.string().optional(),- }- : {}),- });- break;-- case FieldMetadataType.EMAILS: {- const baseSchema = field.isNullable- ? EmailsValueOptionalSchema- : EmailsValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.PHONES: {- const baseSchema = field.isNullable- ? PhonesValueOptionalSchema- : PhonesValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.RICH_TEXT: {- const baseSchema = field.isNullable- ? RichTextValueOptionalSchema- : RichTextValueSchema;-- shape[field.name] = field.description- ? baseSchema.describe(field.description)- : baseSchema;- return;- }-- case FieldMetadataType.FILES:- fieldSchema = filesFieldSchema;- break;-- default:- fieldSchema = getFieldZodType(field);- break;- }-- if (field.name === 'position') {- fieldSchema = z.union([- z.number(),- z.literal('first'),- z.literal('last'),- ]);-- fieldSchema = fieldSchema.describe(- 'Use "first" to insert at the top, "last" for the bottom, or a number for explicit ordering. Leave empty to place at the top (recommended).',- );- } else if (field.description) {- fieldSchema = fieldSchema.describe(field.description);- }-- if (field.isNullable) {- fieldSchema = fieldSchema.optional();- }-- shape[field.name] = fieldSchema;- });-- return z.object(shape);-};diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/shared-filter-defs.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/shared-filter-defs.zod-schema.tsdeleted file mode 100644index 204c7353a6c..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/shared-filter-defs.zod-schema.ts+++ /dev/null@@ -1,264 +0,0 @@-import { z } from 'zod';--export const NullCheckEnum = z- .enum(['NULL', 'NOT_NULL'])- .describe('Is null or not null');--export const TextFilterSchema = z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- in: z.array(z.string()).optional().describe('In array'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- startsWith: z.string().optional().describe('Starts with'),- endsWith: z.string().optional().describe('Ends with'),- is: NullCheckEnum.optional(),- })- .optional();--export const NumberFilterSchema = z- .object({- eq: z.number().optional().describe('Equals'),- neq: z.number().optional().describe('Not equals'),- gt: z.number().optional().describe('>'),- gte: z.number().optional().describe('>='),- lt: z.number().optional().describe('<'),- lte: z.number().optional().describe('<='),- in: z.array(z.number()).optional().describe('In array'),- is: NullCheckEnum.optional(),- })- .optional();--export const DateFilterSchema = z- .object({- eq: z.string().datetime().optional().describe('Equals (ISO datetime)'),- neq: z.string().datetime().optional().describe('Not equals (ISO datetime)'),- gt: z.string().datetime().optional().describe('> ISO datetime'),- gte: z.string().datetime().optional().describe('>= ISO datetime'),- lt: z.string().datetime().optional().describe('< ISO datetime'),- lte: z.string().datetime().optional().describe('<= ISO datetime'),- in: z- .array(z.string().datetime())- .optional()- .describe('In array (ISO datetimes)'),- is: NullCheckEnum.optional(),- })- .optional();--export const BooleanFilterSchema = z- .object({- eq: z.boolean().optional().describe('Equals'),- is: NullCheckEnum.optional(),- })- .optional();--export const UuidFilterSchema = z- .object({- eq: z.string().uuid().optional().describe('Equals'),- neq: z.string().uuid().optional().describe('Not equals'),- in: z.array(z.string().uuid()).optional().describe('In array of values'),- is: NullCheckEnum.optional(),- })- .optional();--export const DefaultFilterSchema = z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional();--export const ArrayFieldFilterSchema = z- .object({- containsIlike: z- .string()- .optional()- .describe('Contains case-insensitive substring'),- is: NullCheckEnum.optional(),- isEmptyArray: z.boolean().optional().describe('Is empty array'),- })- .optional();--// Each is a shared constant so all LINKS/ADDRESS/etc. fields share one $def.--export const LinksFilterSchema = z- .object({- primaryLinkUrl: z- .object({- eq: z.string().url().optional().describe('Equals'),- neq: z.string().url().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();--export const AddressFilterSchema = z- .object({- addressStreet1: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional(),- addressCity: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional(),- addressCountry: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();--export const FullNameFilterSchema = z- .object({- firstName: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- startsWith: z.string().optional().describe('Starts with'),- endsWith: z.string().optional().describe('Ends with'),- is: NullCheckEnum.optional(),- })- .optional(),- lastName: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- startsWith: z.string().optional().describe('Starts with'),- endsWith: z.string().optional().describe('Ends with'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();--export const EmailsFilterSchema = z- .object({- primaryEmail: z- .object({- eq: z.string().email().optional().describe('Equals'),- neq: z.string().email().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();--export const PhonesFilterSchema = z- .object({- primaryPhoneNumber: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();--export const RichTextFilterSchema = z- .object({- markdown: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- like: z.string().optional().describe('LIKE (% wildcard)'),- ilike: z- .string()- .optional()- .describe('ILIKE (% wildcard, case-insensitive)'),- startsWith: z.string().optional().describe('Starts with'),- endsWith: z.string().optional().describe('Ends with'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();--export const CurrencyFilterSchema = z- .object({- amountMicros: z- .object({- eq: z.number().optional().describe('Equals'),- neq: z.number().optional().describe('Not equals'),- gt: z.number().optional().describe('>'),- gte: z.number().optional().describe('>='),- lt: z.number().optional().describe('<'),- lte: z.number().optional().describe('<='),- in: z.array(z.number()).optional().describe('In array'),- is: NullCheckEnum.optional(),- })- .describe(- 'Currency amount in micros (1 unit = 1,000,000 micros). Multiply the user-provided amount by 1,000,000 to build this filter.',- )- .optional(),- currencyCode: z- .object({- eq: z.string().optional().describe('Equals'),- neq: z.string().optional().describe('Not equals'),- in: z.array(z.string()).optional().describe('In array'),- is: NullCheckEnum.optional(),- })- .optional(),- })- .optional();diff --git a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/shared-value-defs.zod-schema.ts b/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/shared-value-defs.zod-schema.tsdeleted file mode 100644index cfc2d273abb..00000000000--- a/packages/twenty-server/src/engine/core-modules/record-crud/zod-schemas/shared-value-defs.zod-schema.ts+++ /dev/null@@ -1,82 +0,0 @@-import { z } from 'zod';--export const UuidValueSchema = z.uuidv4();-export const UuidValueOptionalSchema = UuidValueSchema.optional();--export const LinksValueSchema = z.object({- primaryLinkLabel: z.string().optional(),- primaryLinkUrl: z.string().url().optional(),- secondaryLinks: z- .array(- z.object({- url: z.string().url(),- label: z.string(),- }),- )- .optional(),-});-export const LinksValueOptionalSchema = LinksValueSchema.optional();--const CURRENCY_WRITE_DESCRIPTION =- 'Currency amount in micros (1 unit = 1,000,000 micros). Multiply the user-provided amount by 1,000,000 before writing.';-const CURRENCY_READ_DESCRIPTION =- 'Currency amount in micros (1 unit = 1,000,000 micros). Divide by 1,000,000 to display to users.';--export const CurrencyValueSchema = z.object({- amountMicros: z.number().optional().describe(CURRENCY_WRITE_DESCRIPTION),- currencyCode: z.string().optional(),-});-export const CurrencyValueOptionalSchema = CurrencyValueSchema.optional();--export const CurrencyResponseValueSchema = z.object({- amountMicros: z.number().optional().describe(CURRENCY_READ_DESCRIPTION),- currencyCode: z.string().optional(),-});-export const CurrencyResponseValueOptionalSchema =- CurrencyResponseValueSchema.optional();--export const FullNameValueSchema = z.object({- firstName: z.string().optional(),- lastName: z.string().optional(),-});-export const FullNameValueOptionalSchema = FullNameValueSchema.optional();--export const AddressValueSchema = z.object({- addressStreet1: z.string().optional(),- addressStreet2: z.string().optional(),- addressCity: z.string().optional(),- addressPostcode: z.string().optional(),- addressState: z.string().optional(),- addressCountry: z.string().optional(),- addressLat: z.number().optional(),- addressLng: z.number().optional(),-});-export const AddressValueOptionalSchema = AddressValueSchema.optional();--export const EmailsValueSchema = z.object({- primaryEmail: z.string().email().optional(),- additionalEmails: z.array(z.string().email()).optional(),-});-export const EmailsValueOptionalSchema = EmailsValueSchema.optional();--export const PhonesValueSchema = z.object({- primaryPhoneNumber: z.string().optional(),- primaryPhoneCountryCode: z.string().optional(),- primaryPhoneCallingCode: z.string().optional(),- additionalPhones: z- .array(- z.object({- number: z.string(),- countryCode: z.string().optional(),- callingCode: z.string().optional(),- }),- )- .optional(),-});-export const PhonesValueOptionalSchema = PhonesValueSchema.optional();--export const RichTextValueSchema = z.object({- markdown: z.string().optional(),- blocknote: z.string().optional(),-});-export const RichTextValueOptionalSchema = RichTextValueSchema.optional();diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.tsindex c5d12c131a7..d172c33745b 100644--- a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts@@ -18,15 +18,11 @@ import { generateCreateManyRecordInputSchema } from 'src/engine/core-modules/recimport { generateCreateRecordInputSchema } from 'src/engine/core-modules/record-crud/utils/generate-create-record-input-schema.util';import { generateUpdateManyRecordInputSchema } from 'src/engine/core-modules/record-crud/utils/generate-update-many-record-input-schema.util';import { generateUpdateRecordInputSchema } from 'src/engine/core-modules/record-crud/utils/generate-update-record-input-schema.util';-import { toToolJsonSchema } from 'src/engine/core-modules/record-crud/utils/to-tool-json-schema.util';-import { generateBulkDeleteToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/bulk-delete-tool.zod-schema';-import { DeleteToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/delete-tool.zod-schema';-import { FindOneToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/find-one-tool.zod-schema';-import { generateFindToolInputSchema } from 'src/engine/core-modules/record-crud/zod-schemas/find-tool.zod-schema';-import {- generateGroupByToolInputSchema,- hasGroupByToolInputSchema,-} from 'src/engine/core-modules/record-crud/zod-schemas/group-by-tool.zod-schema';+import { generateBulkDeleteToolInputSchema } from 'src/engine/core-modules/record-crud/json-schemas/bulk-delete-tool.json-schema';+import { DELETE_TOOL_INPUT_SCHEMA } from 'src/engine/core-modules/record-crud/json-schemas/delete-tool.json-schema';+import { FIND_ONE_TOOL_INPUT_SCHEMA } from 'src/engine/core-modules/record-crud/json-schemas/find-one-tool.json-schema';+import { generateFindToolInputSchema } from 'src/engine/core-modules/record-crud/json-schemas/find-tool.json-schema';+import { generateGroupByToolInputSchema } from 'src/engine/core-modules/record-crud/json-schemas/group-by-tool.json-schema';import { type ToolDescriptor } from 'src/engine/core-modules/tool-provider/types/tool-descriptor.type';import { type ToolIndexEntry } from 'src/engine/core-modules/tool-provider/types/tool-index-entry.type';import { type ToolOutput } from 'src/engine/core-modules/tool/types/tool-output.type';@@ -199,9 +195,10 @@ export class DatabaseToolProvider implements ToolProvider {description: `Search for ${objectMetadata.labelPlural} records using flexible filtering criteria. Supports exact matches, pattern matching, ranges, and null checks. Use limit/offset for pagination and orderBy for sorting. Filter fields are top-level arguments — pass each field as its own key (e.g. { id: { eq: "record-id" } }; composite fields take their sub-field: { <field>: { <subField>: { ilike: "%ada%" } } }); do NOT wrap them in a "filter" object and do NOT place a bare operator like "ilike"/"eq" at the top level. Combine conditions with and/or/not. Returns an array of matching records with their full data, plus a "count" of total matches and a "hasNextPage" flag. When "hasNextPage" is true, more records match than were returned: continue with a higher offset (or increase the limit) before concluding a record is absent or answering count/enumeration questions.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`find_many_${snakePlural}`) && {- inputSchema: toToolJsonSchema(- generateFindToolInputSchema(objectMetadata, restrictedFields),- ),+ inputSchema: generateFindToolInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -224,7 +221,7 @@ export class DatabaseToolProvider implements ToolProvider {description: `Retrieve a single ${objectMetadata.labelSingular} by ID.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`find_one_${snakeSingular}`) && {- inputSchema: toToolJsonSchema(FindOneToolInputSchema),+ inputSchema: FIND_ONE_TOOL_INPUT_SCHEMA,}),executionRef: {kind: 'database_crud',@@ -237,17 +234,12 @@ export class DatabaseToolProvider implements ToolProvider {});const groupByName = `group_by_${snakePlural}`;- const shouldGenerateGroupBy = shouldIncludeSchema(groupByName);- const groupBySchema = shouldGenerateGroupBy- ? generateGroupByToolInputSchema(objectMetadata, restrictedFields)+ const shouldIncludeGroupBySchema = shouldIncludeSchema(groupByName);+ const groupBySchema = shouldIncludeGroupBySchema+ ? generateGroupByToolInputSchema({ objectMetadata, restrictedFields }): null;- const hasGroupBySchema =- !includeSchemas ||- groupBySchema !== null ||- hasGroupByToolInputSchema(objectMetadata, restrictedFields);-- if (hasGroupBySchema) {+ if (!shouldIncludeGroupBySchema || isDefined(groupBySchema)) {descriptors.push({name: groupByName,...getCrudToolLabels(@@ -258,10 +250,7 @@ export class DatabaseToolProvider implements ToolProvider {),description: `Group ${objectMetadata.labelPlural} records by one or two fields and compute an aggregate (COUNT, SUM, AVG, MIN, MAX, etc.). Use for questions like "how many deals per stage?" or "total revenue by company". Returns groups with dimension values and aggregate results, ordered by the aggregate value.`,category: ToolCategory.DATABASE_CRUD,- ...(shouldGenerateGroupBy &&- groupBySchema && {- inputSchema: toToolJsonSchema(groupBySchema),- }),+ ...(isDefined(groupBySchema) && { inputSchema: groupBySchema }),executionRef: {kind: 'database_crud',objectNameSingular: objectMetadata.nameSingular,@@ -286,9 +275,10 @@ export class DatabaseToolProvider implements ToolProvider {description: `Create a new ${objectMetadata.labelSingular} record. Provide all required fields and any optional fields you want to set. The system will automatically handle timestamps and IDs. Returns the created record with all its data.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`create_one_${snakeSingular}`) && {- inputSchema: toToolJsonSchema(- generateCreateRecordInputSchema(objectMetadata, restrictedFields),- ),+ inputSchema: generateCreateRecordInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -311,12 +301,10 @@ export class DatabaseToolProvider implements ToolProvider {description: `Create multiple ${objectMetadata.labelPlural} records in a single call. Provide an array of records, each containing the required fields. Maximum 20 records per call. Returns the created records.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`create_many_${snakePlural}`) && {- inputSchema: toToolJsonSchema(- generateCreateManyRecordInputSchema(- objectMetadata,- restrictedFields,- ),- ),+ inputSchema: generateCreateManyRecordInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -339,9 +327,10 @@ export class DatabaseToolProvider implements ToolProvider {description: `Update an existing ${objectMetadata.labelSingular} record. Provide the record ID and only the fields you want to change. Unspecified fields will remain unchanged. Returns the updated record with all current data.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`update_one_${snakeSingular}`) && {- inputSchema: toToolJsonSchema(- generateUpdateRecordInputSchema(objectMetadata, restrictedFields),- ),+ inputSchema: generateUpdateRecordInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -364,12 +353,10 @@ export class DatabaseToolProvider implements ToolProvider {description: `Apply the SAME field values to all ${objectMetadata.labelPlural} records matching a filter. Use when every matched record gets identical changes (e.g. bulk status change). For records that each have different data to update, use upsert_many_${snakePlural} instead. WARNING: Use specific filters to avoid unintended mass updates. Always verify the filter scope with a find query first.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`update_many_${snakePlural}`) && {- inputSchema: toToolJsonSchema(- generateUpdateManyRecordInputSchema(- objectMetadata,- restrictedFields,- ),- ),+ inputSchema: generateUpdateManyRecordInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -392,12 +379,10 @@ export class DatabaseToolProvider implements ToolProvider {description: `Insert or update multiple ${objectMetadata.labelPlural} records in a single call, where each record has its own individual data. Use this instead of update_many_${snakePlural} when records need different field values. Existing records are matched by unique fields and updated; records with no match are created. Maximum 20 records per call. Returns the upserted records.`,category: ToolCategory.DATABASE_CRUD,...(shouldIncludeSchema(`upsert_many_${snakePlural}`) && {- inputSchema: toToolJsonSchema(- generateCreateManyRecordInputSchema(- objectMetadata,- restrictedFields,- ),- ),+ inputSchema: generateCreateManyRecordInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -421,8 +406,8 @@ export class DatabaseToolProvider implements ToolProvider {),description: `Delete a ${objectMetadata.labelSingular} record by marking it as deleted. The record is hidden from normal queries. This is reversible. Use this to remove records.`,category: ToolCategory.DATABASE_CRUD,- ...(includeSchemas && {- inputSchema: toToolJsonSchema(DeleteToolInputSchema),+ ...(shouldIncludeSchema(`delete_one_${snakeSingular}`) && {+ inputSchema: DELETE_TOOL_INPUT_SCHEMA,}),executionRef: {kind: 'database_crud',@@ -444,13 +429,11 @@ export class DatabaseToolProvider implements ToolProvider {),description: `Soft-delete multiple ${objectMetadata.labelPlural} records matching a filter in a single operation. Deleted records are hidden from normal queries and the operation is reversible. WARNING: Use specific filters to avoid unintended mass deletions.`,category: ToolCategory.DATABASE_CRUD,- ...(includeSchemas && {- inputSchema: toToolJsonSchema(- generateBulkDeleteToolInputSchema(- objectMetadata,- restrictedFields,- ),- ),+ ...(shouldIncludeSchema(`delete_many_${snakePlural}`) && {+ inputSchema: generateBulkDeleteToolInputSchema({+ objectMetadata,+ restrictedFields,+ }),}),executionRef: {kind: 'database_crud',@@ -491,18 +474,17 @@ export class DatabaseToolProvider implements ToolProvider {);return (flatObject) =>- getFlatFieldsFromFlatObjectMetadata(- flatObject,- flatFieldMetadataMaps,- ).map((flatFieldMetadata) => ({- ...flatFieldMetadata,- description: resolveEffectiveFieldDescription({- flatFieldMetadata,- locale: context.locale,- i18nInstance,- workspaceCustomApplicationUniversalIdentifier,- }),- }));+ getFlatFieldsFromFlatObjectMetadata(flatObject, flatFieldMetadataMaps)+ .sort((fieldA, fieldB) => fieldA.name.localeCompare(fieldB.name))+ .map((flatFieldMetadata) => ({+ ...flatFieldMetadata,+ description: resolveEffectiveFieldDescription({+ flatFieldMetadata,+ locale: context.locale,+ i18nInstance,+ workspaceCustomApplicationUniversalIdentifier,+ }),+ }));}private hasMatchingTool(diff --git a/packages/twenty-server/test/integration/ai/suites/__snapshots__/mcp-database-tool-input-schemas.integration-spec.ts.snap b/packages/twenty-server/test/integration/ai/suites/__snapshots__/mcp-database-tool-input-schemas.integration-spec.ts.snapindex dcc1a83a309..65d61fd3b3a 100644--- a/packages/twenty-server/test/integration/ai/suites/__snapshots__/mcp-database-tool-input-schemas.integration-spec.ts.snap+++ b/packages/twenty-server/test/integration/ai/suites/__snapshots__/mcp-database-tool-input-schemas.integration-spec.ts.snap@@ -417,7 +417,7 @@ exports[`MCP database tool input schemas should list the input schemas of the no"additionalProperties": false,"properties": {"aggregateFieldName": {- "description": "Field to aggregate. Required for any operation other than COUNT. Available fields: id, createdAt, updatedAt, deletedAt, position, title, bodyV2, createdBy, updatedBy, searchVector.",+ "description": "Field to aggregate. Required for any operation other than COUNT. Available fields: bodyV2, createdAt, createdBy, deletedAt, id, position, searchVector, title, updatedAt, updatedBy.","type": "string",},"aggregateOperation": {@@ -489,9 +489,53 @@ exports[`MCP database tool input schemas should list the input schemas of the no"type": "object",},"groupBy": {- "description": "Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: createdAt (date), updatedAt (date), title, bodyV2.blocknote, bodyV2.markdown.",+ "description": "Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: bodyV2.blocknote, bodyV2.markdown, createdAt (date), title, updatedAt (date).","items": {"anyOf": [+ {+ "additionalProperties": false,+ "properties": {+ "bodyV2": {+ "additionalProperties": false,+ "properties": {+ "blocknote": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "blocknote",+ ],+ "type": "object",+ },+ },+ "required": [+ "bodyV2",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "bodyV2": {+ "additionalProperties": false,+ "properties": {+ "markdown": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "markdown",+ ],+ "type": "object",+ },+ },+ "required": [+ "bodyV2",+ ],+ "type": "object",+ },{"additionalProperties": false,"properties": {@@ -537,6 +581,19 @@ exports[`MCP database tool input schemas should list the input schemas of the no],"type": "object",},+ {+ "additionalProperties": false,+ "properties": {+ "title": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "title",+ ],+ "type": "object",+ },{"additionalProperties": false,"properties": {@@ -582,63 +639,6 @@ exports[`MCP database tool input schemas should list the input schemas of the no],"type": "object",},- {- "additionalProperties": false,- "properties": {- "title": {- "const": true,- "type": "boolean",- },- },- "required": [- "title",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "bodyV2": {- "additionalProperties": false,- "properties": {- "blocknote": {- "const": true,- "type": "boolean",- },- },- "required": [- "blocknote",- ],- "type": "object",- },- },- "required": [- "bodyV2",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "bodyV2": {- "additionalProperties": false,- "properties": {- "markdown": {- "const": true,- "type": "boolean",- },- },- "required": [- "markdown",- ],- "type": "object",- },- },- "required": [- "bodyV2",- ],- "type": "object",- },],},"maxItems": 2,@@ -3008,7 +3008,7 @@ exports[`MCP database tool input schemas should list the input schemas of the pe"type": "object",},"aggregateFieldName": {- "description": "Field to aggregate. Required for any operation other than COUNT. Available fields: name, id, createdAt, createdBy, deletedAt, position, updatedAt, updatedBy, searchVector, species, traits, comments, age, location, vetPhone, vetEmail, birthday, isGoodWithKids, pictures, averageCostOfKibblePerMonth, averageCostOfKibblePerMonth.amountMicros, makesOwnerThinkOf, soundSwag, bio, interestingFacts, extraData, polymorphicOwnerSurveyResult, polymorphicOwnerRocket, polymorphicHelperSurveyResults, polymorphicHelperRockets.",+ "description": "Field to aggregate. Required for any operation other than COUNT. Available fields: age, averageCostOfKibblePerMonth, averageCostOfKibblePerMonth.amountMicros, bio, birthday, comments, createdAt, createdBy, deletedAt, extraData, id, interestingFacts, isGoodWithKids, location, makesOwnerThinkOf, name, pictures, polymorphicHelperRockets, polymorphicHelperSurveyResults, polymorphicOwnerRocket, polymorphicOwnerSurveyResult, position, searchVector, soundSwag, species, traits, updatedAt, updatedBy, vetEmail, vetPhone.","type": "string",},"aggregateOperation": {@@ -3284,26 +3284,83 @@ exports[`MCP database tool input schemas should list the input schemas of the pe"type": "object",},"groupBy": {- "description": "Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: name, createdAt (date), updatedAt (date), species, traits (multi-value, {"traits": {"unnest": true}} counts each value), comments, age, location.addressStreet1, location.addressStreet2, location.addressCity, location.addressPostcode, location.addressState, location.addressCountry, location.addressLat, location.addressLng, vetPhone.primaryPhoneNumber, vetPhone.primaryPhoneCountryCode, vetPhone.primaryPhoneCallingCode, vetEmail.primaryEmail, birthday (date), isGoodWithKids, pictures.primaryLinkLabel, pictures.primaryLinkUrl, averageCostOfKibblePerMonth.amountMicros, averageCostOfKibblePerMonth.currencyCode, makesOwnerThinkOf.firstName, makesOwnerThinkOf.lastName, soundSwag, bio, interestingFacts (multi-value, {"interestingFacts": {"unnest": true}} counts each value), polymorphicOwnerSurveyResultId, polymorphicOwnerRocketId.",+ "description": "Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: age, averageCostOfKibblePerMonth.amountMicros, averageCostOfKibblePerMonth.currencyCode, bio, birthday (date), comments, createdAt (date), interestingFacts (multi-value, {"interestingFacts": {"unnest": true}} counts each value), isGoodWithKids, location.addressStreet1, location.addressStreet2, location.addressCity, location.addressPostcode, location.addressState, location.addressCountry, location.addressLat, location.addressLng, makesOwnerThinkOf.firstName, makesOwnerThinkOf.lastName, name, pictures.primaryLinkLabel, pictures.primaryLinkUrl, polymorphicOwnerRocketId, polymorphicOwnerSurveyResultId, soundSwag, species, traits (multi-value, {"traits": {"unnest": true}} counts each value), updatedAt (date), vetEmail.primaryEmail, vetPhone.primaryPhoneNumber, vetPhone.primaryPhoneCountryCode, vetPhone.primaryPhoneCallingCode.","items": {"anyOf": [{"additionalProperties": false,"properties": {- "name": {+ "age": {"const": true,"type": "boolean",},},"required": [- "name",+ "age",],"type": "object",},{"additionalProperties": false,"properties": {- "createdAt": {+ "averageCostOfKibblePerMonth": {+ "additionalProperties": false,+ "properties": {+ "amountMicros": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "amountMicros",+ ],+ "type": "object",+ },+ },+ "required": [+ "averageCostOfKibblePerMonth",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "averageCostOfKibblePerMonth": {+ "additionalProperties": false,+ "properties": {+ "currencyCode": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "currencyCode",+ ],+ "type": "object",+ },+ },+ "required": [+ "averageCostOfKibblePerMonth",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "bio": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "bio",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "birthday": {"additionalProperties": false,"description": "Date field grouping configuration","properties": {@@ -3341,14 +3398,27 @@ exports[`MCP database tool input schemas should list the input schemas of the pe},},"required": [- "createdAt",+ "birthday",],"type": "object",},{"additionalProperties": false,"properties": {- "updatedAt": {+ "comments": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "comments",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "createdAt": {"additionalProperties": false,"description": "Date field grouping configuration","properties": {@@ -3386,27 +3456,14 @@ exports[`MCP database tool input schemas should list the input schemas of the pe},},"required": [- "updatedAt",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "species": {- "const": true,- "type": "boolean",- },- },- "required": [- "species",+ "createdAt",],"type": "object",},{"additionalProperties": false,"properties": {- "traits": {+ "interestingFacts": {"anyOf": [{"const": true,@@ -3429,33 +3486,20 @@ exports[`MCP database tool input schemas should list the input schemas of the pe},},"required": [- "traits",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "comments": {- "const": true,- "type": "boolean",- },- },- "required": [- "comments",+ "interestingFacts",],"type": "object",},{"additionalProperties": false,"properties": {- "age": {+ "isGoodWithKids": {"const": true,"type": "boolean",},},"required": [- "age",+ "isGoodWithKids",],"type": "object",},@@ -3638,360 +3682,316 @@ exports[`MCP database tool input schemas should list the input schemas of the pe{"additionalProperties": false,"properties": {- "vetPhone": {+ "makesOwnerThinkOf": {"additionalProperties": false,"properties": {- "primaryPhoneNumber": {+ "firstName": {"const": true,"type": "boolean",},},"required": [- "primaryPhoneNumber",+ "firstName",],"type": "object",},},"required": [- "vetPhone",+ "makesOwnerThinkOf",],"type": "object",},{"additionalProperties": false,"properties": {- "vetPhone": {+ "makesOwnerThinkOf": {"additionalProperties": false,"properties": {- "primaryPhoneCountryCode": {+ "lastName": {"const": true,"type": "boolean",},},"required": [- "primaryPhoneCountryCode",+ "lastName",],"type": "object",},},"required": [- "vetPhone",+ "makesOwnerThinkOf",],"type": "object",},{"additionalProperties": false,"properties": {- "vetPhone": {+ "name": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "name",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "pictures": {"additionalProperties": false,"properties": {- "primaryPhoneCallingCode": {+ "primaryLinkLabel": {"const": true,"type": "boolean",},},"required": [- "primaryPhoneCallingCode",+ "primaryLinkLabel",],"type": "object",},},"required": [- "vetPhone",+ "pictures",],"type": "object",},{"additionalProperties": false,"properties": {- "vetEmail": {+ "pictures": {"additionalProperties": false,"properties": {- "primaryEmail": {+ "primaryLinkUrl": {"const": true,"type": "boolean",},},"required": [- "primaryEmail",+ "primaryLinkUrl",],"type": "object",},},"required": [- "vetEmail",+ "pictures",],"type": "object",},{"additionalProperties": false,"properties": {- "birthday": {- "additionalProperties": false,- "description": "Date field grouping configuration",- "properties": {- "granularity": {- "default": "MONTH",- "description": "Date grouping granularity. Default: MONTH.",- "enum": [- "DAY",- "MONTH",- "QUARTER",- "YEAR",- "WEEK",- "DAY_OF_THE_WEEK",- "MONTH_OF_THE_YEAR",- "QUARTER_OF_THE_YEAR",- ],- "type": "string",- },- "timeZone": {- "default": "UTC",- "description": "IANA timezone for date groupings (e.g. "America/New_York"). Default: UTC.",- "type": "string",- },- "weekStartDay": {- "description": "First day of week (MONDAY, SUNDAY, SATURDAY). Only used when granularity is WEEK.",- "enum": [- "MONDAY",- "SUNDAY",- "SATURDAY",- ],- "type": "string",- },- },- "type": "object",+ "polymorphicOwnerRocketId": {+ "const": true,+ "type": "boolean",},},"required": [- "birthday",+ "polymorphicOwnerRocketId",],"type": "object",},{"additionalProperties": false,"properties": {- "isGoodWithKids": {+ "polymorphicOwnerSurveyResultId": {"const": true,"type": "boolean",},},"required": [- "isGoodWithKids",+ "polymorphicOwnerSurveyResultId",],"type": "object",},{"additionalProperties": false,"properties": {- "pictures": {- "additionalProperties": false,- "properties": {- "primaryLinkLabel": {- "const": true,- "type": "boolean",- },- },- "required": [- "primaryLinkLabel",- ],- "type": "object",+ "soundSwag": {+ "const": true,+ "type": "boolean",},},"required": [- "pictures",+ "soundSwag",],"type": "object",},{"additionalProperties": false,"properties": {- "pictures": {- "additionalProperties": false,- "properties": {- "primaryLinkUrl": {+ "species": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "species",+ ],+ "type": "object",+ },+ {+ "additionalProperties": false,+ "properties": {+ "traits": {+ "anyOf": [+ {"const": true,"type": "boolean",},- },- "required": [- "primaryLinkUrl",+ {+ "additionalProperties": false,+ "properties": {+ "unnest": {+ "const": true,+ "type": "boolean",+ },+ },+ "required": [+ "unnest",+ ],+ "type": "object",+ },],- "type": "object",},},"required": [- "pictures",+ "traits",],"type": "object",},{"additionalProperties": false,"properties": {- "averageCostOfKibblePerMonth": {+ "updatedAt": {"additionalProperties": false,+ "description": "Date field grouping configuration","properties": {- "amountMicros": {- "const": true,- "type": "boolean",+ "granularity": {+ "default": "MONTH",+ "description": "Date grouping granularity. Default: MONTH.",+ "enum": [+ "DAY",+ "MONTH",+ "QUARTER",+ "YEAR",+ "WEEK",+ "DAY_OF_THE_WEEK",+ "MONTH_OF_THE_YEAR",+ "QUARTER_OF_THE_YEAR",+ ],+ "type": "string",+ },+ "timeZone": {+ "default": "UTC",+ "description": "IANA timezone for date groupings (e.g. "America/New_York"). Default: UTC.",+ "type": "string",+ },+ "weekStartDay": {+ "description": "First day of week (MONDAY, SUNDAY, SATURDAY). Only used when granularity is WEEK.",+ "enum": [+ "MONDAY",+ "SUNDAY",+ "SATURDAY",+ ],+ "type": "string",},},- "required": [- "amountMicros",- ],"type": "object",},},"required": [- "averageCostOfKibblePerMonth",+ "updatedAt",],"type": "object",},{"additionalProperties": false,"properties": {- "averageCostOfKibblePerMonth": {+ "vetEmail": {"additionalProperties": false,"properties": {- "currencyCode": {+ "primaryEmail": {"const": true,"type": "boolean",},},"required": [- "currencyCode",+ "primaryEmail",],"type": "object",},},"required": [- "averageCostOfKibblePerMonth",+ "vetEmail",],"type": "object",},{"additionalProperties": false,"properties": {- "makesOwnerThinkOf": {+ "vetPhone": {"additionalProperties": false,"properties": {- "firstName": {+ "primaryPhoneNumber": {"const": true,"type": "boolean",},},"required": [- "firstName",+ "primaryPhoneNumber",],"type": "object",},},"required": [- "makesOwnerThinkOf",+ "vetPhone",],"type": "object",},{"additionalProperties": false,"properties": {- "makesOwnerThinkOf": {+ "vetPhone": {"additionalProperties": false,"properties": {- "lastName": {+ "primaryPhoneCountryCode": {"const": true,"type": "boolean",},},"required": [- "lastName",+ "primaryPhoneCountryCode",],"type": "object",},},"required": [- "makesOwnerThinkOf",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "soundSwag": {- "const": true,- "type": "boolean",- },- },- "required": [- "soundSwag",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "bio": {- "const": true,- "type": "boolean",- },- },- "required": [- "bio",+ "vetPhone",],"type": "object",},{"additionalProperties": false,"properties": {- "interestingFacts": {- "anyOf": [- {+ "vetPhone": {+ "additionalProperties": false,+ "properties": {+ "primaryPhoneCallingCode": {"const": true,"type": "boolean",},- {- "additionalProperties": false,- "properties": {- "unnest": {- "const": true,- "type": "boolean",- },- },- "required": [- "unnest",- ],- "type": "object",- },+ },+ "required": [+ "primaryPhoneCallingCode",],+ "type": "object",},},"required": [- "interestingFacts",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "polymorphicOwnerSurveyResultId": {- "const": true,- "type": "boolean",- },- },- "required": [- "polymorphicOwnerSurveyResultId",- ],- "type": "object",- },- {- "additionalProperties": false,- "properties": {- "polymorphicOwnerRocketId": {- "const": true,- "type": "boolean",- },- },- "required": [- "polymorphicOwnerRocketId",+ "vetPhone",],"type": "object",},@@ -7840,7 +7840,7 @@ exports[`MCP database tool input schemas should list the input schemas of the su"additionalProperties": false,"properties": {"aggregateFieldName": {- "description": "Field to aggregate. Required for any operation other than COUNT. Available fields: name, id, createdAt, createdBy, deletedAt, position, updatedAt, updatedBy, searchVector, score, percentageOfCompletion, participants, averageEstimatedNumberOfAtomsInTheUniverse, comments, shortNotes, files.",+ "description": "Field to aggregate. Required for any operation other than COUNT. Available fields: averageEstimatedNumberOfAtomsInTheUniverse, comments, createdAt, createdBy, deletedAt, files, id, name, participants, percentageOfCompletion, position, score, searchVector, shortNotes, updatedAt, updatedBy.","type": "string",},"aggregateOperation": {@@ -7987,71 +7987,39 @@ exports[`MCP database tool input schemas should list the input schemas of the su"type": "object",},"groupBy": {- "description": "Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: name, createdAt (date), updatedAt (date), score, percentageOfCompletion, participants, averageEstimatedNumberOfAtomsInTheUniverse, comments, shortNotes, helpedPetsId.",+ "description": "Fields to group by (max 2). Each entry must be an object with exactly one field key. At most one entry can use unnest. A record with several values is counted in each group, so totals can exceed the record count. Examples: {"status": true}, {"companyId": true}, {"createdAt": {"granularity": "MONTH", "timeZone": "UTC"}}. Available: averageEstimatedNumberOfAtomsInTheUniverse, comments, createdAt (date), helpedPetsId, name, participants, percentageOfCompletion, score, shortNotes, updatedAt (date).","items": {"anyOf": [{"additionalProperties": false,"properties": {- "name": {+ "averageEstimatedNumberOfAtomsInTheUniverse": {"const": true,"type": "boolean",},},"required": [- "name",+ "averageEstimatedNumberOfAtomsInTheUniverse",],"type": "object",},{"additionalProperties": false,"properties": {- "createdAt": {- "additionalProperties": false,- "description": "Date field grouping configuration",- "properties": {- "granularity": {- "default": "MONTH",- "description": "Date grouping granularity. Default: MONTH.",- "enum": [- "DAY",- "MONTH",- "QUARTER",- "YEAR",- "WEEK",- "DAY_OF_THE_WEEK",- "MONTH_OF_THE_YEAR",- "QUARTER_OF_THE_YEAR",- ],- "type": "string",- },- "timeZone": {- "default": "UTC",- "description": "IANA timezone for date groupings (e.g. "America/New_York"). Default: UTC.",- "type": "string",- },- "weekStartDay": {- "description": "First day of week (MONDAY, SUNDAY, SATURDAY). Only used when granularity is WEEK.",- "enum": [- "MONDAY",- "SUNDAY",- "SATURDAY",- ],- "type": "string",- },- },- "type": "object",+ "comments": {+ "const": true,+ "type": "boolean",},},"required": [- "createdAt",+ "comments",],"type": "object",},{"additionalProperties": false,"properties": {- "updatedAt": {+ "createdAt": {"additionalProperties": false,"description": "Date field grouping configuration","properties": {@@ -8089,33 +8057,33 @@ exports[`MCP database tool input schemas should list the input schemas of the su},},"required": [- "updatedAt",+ "createdAt",],"type": "object",},{"additionalProperties": false,"properties": {- "score": {+ "helpedPetsId": {"const": true,"type": "boolean",},},"required": [- "score",+ "helpedPetsId",],"type": "object",},{"additionalProperties": false,"properties": {- "percentageOfCompletion": {+ "name": {"const": true,"type": "boolean",},},"required": [- "percentageOfCompletion",+ "name",],"type": "object",},@@ -8135,26 +8103,26 @@ exports[`MCP database tool input schemas should list the input schemas of the su{"additionalProperties": false,"properties": {- "averageEstimatedNumberOfAtomsInTheUniverse": {+ "percentageOfCompletion": {"const": true,"type": "boolean",},},"required": [- "averageEstimatedNumberOfAtomsInTheUniverse",+ "percentageOfCompletion",],"type": "object",},{"additionalProperties": false,"properties": {- "comments": {+ "score": {"const": true,"type": "boolean",},},"required": [- "comments",+ "score",],"type": "object",},@@ -8174,13 +8142,45 @@ exports[`MCP database tool input schemas should list the input schemas of the su{"additionalProperties": false,"properties": {- "helpedPetsId": {- "const": true,- "type": "boolean",+ "updatedAt": {+ "additionalProperties": false,+ "description": "Date field grouping configuration",+ "properties": {+ "granularity": {+ "default": "MONTH",+ "description": "Date grouping granularity. Default: MONTH.",+ "enum": [+ "DAY",+ "MONTH",+ "QUARTER",+ "YEAR",+ "WEEK",+ "DAY_OF_THE_WEEK",+ "MONTH_OF_THE_YEAR",+ "QUARTER_OF_THE_YEAR",+ ],+ "type": "string",+ },+ "timeZone": {+ "default": "UTC",+ "description": "IANA timezone for date groupings (e.g. "America/New_York"). Default: UTC.",+ "type": "string",+ },+ "weekStartDay": {+ "description": "First day of week (MONDAY, SUNDAY, SATURDAY). Only used when granularity is WEEK.",+ "enum": [+ "MONDAY",+ "SUNDAY",+ "SATURDAY",+ ],+ "type": "string",+ },+ },+ "type": "object",},},"required": [- "helpedPetsId",+ "updatedAt",],"type": "object",},