Infer record pickers for record-typed logic function workflow inputs (#21494)

## Context

Logic functions can declare workflow inputs typed as records or arrays
of records (e.g. the People Data Labs enrichment functions), but the
workflow builder rendered those as a plain text input with a variable
picker, which is not usable.

## What this does

- Adds an `objectUniversalIdentifier` link on input schema properties,
so a record-typed input is tied to a workspace object.
- The SDK build infers it from a
`TwentyRecord<'objectUniversalIdentifier'>` marker type in the handler
signature, reading the object's universal identifier straight from the
source; explicit input schemas can still set the field directly.
- The workflow builder renders these inputs as a single record picker or
a record multi-select with the variable picker on the right. Selected
records are stored as record ids; `TwentyRecord<UID>` is a branded
`string`, so the handler signature reflects that it receives ids (a
bound variable resolves to whatever the referenced step produced).
- The multi-select collapses overflowing chips into a `+N` badge
(reusing `ExpandableList`) and its variable picker offers both record
objects and fields.
- Updates the People Data Labs enrichment inputs as the reference
implementation.

<img width="802" height="824" alt="CleanShot 2026-06-12 at 16 54 10@2x"
src="https://github.com/user-attachments/assets/a0896d74-0aab-49bd-a173-14c578a2e533"
/>


<!-- This is an auto-generated description by cubic. -->
<a
href="https://cubic.dev/pr/twentyhq/twenty/pull/21494?utm_source=github"
target="_blank" rel="noopener noreferrer"
data-no-image-dialog="true"><picture><source
media="(prefers-color-scheme: dark)"
srcset="https://www.cubic.dev/buttons/review-in-cubic-dark.svg"><source
media="(prefers-color-scheme: light)"
srcset="https://www.cubic.dev/buttons/review-in-cubic-light.svg"><img
alt="Review in cubic"
src="https://www.cubic.dev/buttons/review-in-cubic-dark.svg"></picture></a>
<!-- End of auto-generated description by cubic. -->

packages/twenty-shared/src/logic-function/get-function-input-schema.ts

@@ -20,6 +20,32 @@ import {
 import { type InputJsonSchema } from '@/logic-function';
 import { isDefined } from '@/utils/validation/isDefined';
 
+const TWENTY_RECORD_TYPE_NAME = 'TwentyRecord';
+
+const getObjectUniversalIdentifierFromTypeArgument = (
+  typeReferenceNode: TypeReferenceNode,
+): string | undefined => {
+  const typeArgument = typeReferenceNode.typeArguments?.[0];
+
+  if (
+    isDefined(typeArgument) &&
+    typeArgument.kind === SyntaxKind.LiteralType &&
+    (typeArgument as LiteralTypeNode).literal.kind === SyntaxKind.StringLiteral
+  ) {
+    return ((typeArgument as LiteralTypeNode).literal as StringLiteral).text;
+  }
+
+  return undefined;
+};
+
+const buildArraySchemaFromItems = (items: InputJsonSchema): InputJsonSchema =>
+  items.type === 'record'
+    ? {
+        type: 'records',
+        objectUniversalIdentifier: items.objectUniversalIdentifier,
+      }
+    : { type: 'array', items };
+
 const getTypeString = (typeNode: TypeNode): InputJsonSchema => {
   switch (typeNode.kind) {
     case SyntaxKind.NumberKeyword:
@@ -29,10 +55,9 @@ const getTypeString = (typeNode: TypeNode): InputJsonSchema => {
     case SyntaxKind.BooleanKeyword:
       return { type: 'boolean' };
     case SyntaxKind.ArrayType:
-      return {
-        type: 'array',
-        items: getTypeString((typeNode as ArrayTypeNode).elementType),
-      };
+      return buildArraySchemaFromItems(
+        getTypeString((typeNode as ArrayTypeNode).elementType),
+      );
     case SyntaxKind.TypeReference: {
       const typeReferenceNode = typeNode as TypeReferenceNode;
       const typeName =
@@ -43,10 +68,18 @@ const getTypeString = (typeNode: TypeNode): InputJsonSchema => {
       if (typeName === 'Array' || typeName === 'ReadonlyArray') {
         const elementType = typeReferenceNode.typeArguments?.[0];
 
-        return {
-          type: 'array',
-          items: isDefined(elementType) ? getTypeString(elementType) : {},
-        };
+        return buildArraySchemaFromItems(
+          isDefined(elementType) ? getTypeString(elementType) : {},
+        );
+      }
+
+      if (typeName === TWENTY_RECORD_TYPE_NAME) {
+        const objectUniversalIdentifier =
+          getObjectUniversalIdentifierFromTypeArgument(typeReferenceNode);
+
+        if (isDefined(objectUniversalIdentifier)) {
+          return { type: 'record', objectUniversalIdentifier };
+        }
       }
 
       return {};