[Automatic Import] Add date field mapping (elastic#261580)

## Summary

Fixes custom date fields being incorrectly mapped as `keyword` in
generated `fields.yml` for automatic import integrations.

The review agent produces `field_mappings` with accurate types
(including `date`), but these were discarded after the agent completed.
Instead, `generateFieldMappings` inferred types purely from JavaScript
value types in pipeline output documents — and since dates are strings
in JSON, they were always classified as `keyword`.

This PR threads the agent's `field_mappings` through to
`generateFieldMappings` so that agent-determined types (especially
`date`) are preserved in the data stream saved object and subsequently
in the built integration package's `fields.yml`.

### Changes

- **`fields.ts`**: Added an optional `agentFieldMappings` parameter to
`generateFieldMappings`. When provided, agent types override heuristic
inference for non-ECS fields. ECS types retain highest precedence.
- **`task_manager_service.ts`**: After the agent completes, extracts
`result.field_mappings` from the agent state and passes it to
`generateFieldMappings`.

### How it flows end-to-end

1. Review agent calls `submit_review` with `field_mappings` (e.g.
`[{name: "my_app.created_at", type: "date"}]`)
2. Agent state includes these in `result.field_mappings`
3. Task manager passes them to `generateFieldMappings` as type hints
4. `generateFieldMappings` uses agent types for non-ECS fields, falling
back to heuristic inference
5. Correct types are stored in the data stream saved object's
`result.field_mapping`
6. `buildIntegrationPackage` reads `field_mapping` from the saved object
and generates `fields.yml` with correct `date` types

Note: The manual pipeline edit path (`updateDataStreamPipeline`) is
unaffected — it does not have agent field mappings available, so it
continues to use heuristic inference only.

## Test plan

- [x] `fields.test.ts`: 4 new tests covering agent override, ECS
precedence, fallback, and empty array
- [x] `task_manager_service.test.ts`: 2 new tests verifying agent field
mappings are passed through (present and absent cases)
- [x] Verify end-to-end: create an integration with a data source
containing date fields, confirm `fields.yml` in the downloaded package
uses `type: date` instead of `type: keyword`

---------

Co-authored-by: kibanamachine <42973632+kibanamachine@users.noreply.github.com>

Author: bhapas

x-pack/platform/plugins/shared/automatic_import/server/services/build_integration/fields.test.ts

@@ -268,6 +268,91 @@ describe('fields', () => {
       expect(fieldNames).not.toContain('__proto__.bad');
     });
 
+    it('uses agent field mappings to override inferred types for non-ECS fields', async () => {
+      const docs = [
+        {
+          my_app: {
+            created_at: '2024-01-15T10:30:00.000Z',
+            updated_at: '2024-01-16T12:00:00.000Z',
+            name: 'test',
+            count: 5,
+          },
+        },
+      ];
+      const agentFieldMappings = [
+        { name: 'my_app.created_at', type: 'date' as const },
+        { name: 'my_app.updated_at', type: 'date' as const },
+        { name: 'my_app.name', type: 'keyword' as const },
+      ];
+      const fields = await generateFieldMappings(docs, fieldsMetadataClient, agentFieldMappings);
+
+      expect(fields).toContainEqual({
+        name: 'my_app.created_at',
+        type: 'date',
+        is_ecs: false,
+      });
+      expect(fields).toContainEqual({
+        name: 'my_app.updated_at',
+        type: 'date',
+        is_ecs: false,
+      });
+      expect(fields).toContainEqual({
+        name: 'my_app.name',
+        type: 'keyword',
+        is_ecs: false,
+      });
+      expect(fields).toContainEqual({
+        name: 'my_app.count',
+        type: 'long',
+        is_ecs: false,
+      });
+    });
+
+    it('ECS types take precedence over agent field mappings', async () => {
+      const docs = [
+        {
+          '@timestamp': '2024-01-01T00:00:00.000Z',
+          source: { ip: '10.0.0.1' },
+        },
+      ];
+      const agentFieldMappings = [
+        { name: '@timestamp', type: 'keyword' as const },
+        { name: 'source.ip', type: 'keyword' as const },
+      ];
+      const fields = await generateFieldMappings(docs, fieldsMetadataClient, agentFieldMappings);
+
+      expect(fields).toContainEqual({ name: '@timestamp', type: 'date', is_ecs: true });
+      expect(fields).toContainEqual({ name: 'source.ip', type: 'ip', is_ecs: true });
+    });
+
+    it('falls back to inferred type when agent field mappings are not provided', async () => {
+      const docs = [
+        {
+          my_app: {
+            timestamp: '2024-01-01T00:00:00.000Z',
+          },
+        },
+      ];
+      const fields = await generateFieldMappings(docs, fieldsMetadataClient);
+
+      expect(fields).toContainEqual({
+        name: 'my_app.timestamp',
+        type: 'keyword',
+        is_ecs: false,
+      });
+    });
+
+    it('handles empty agent field mappings array', async () => {
+      const docs = [{ my_app: { value: 'test' } }];
+      const fields = await generateFieldMappings(docs, fieldsMetadataClient, []);
+
+      expect(fields).toContainEqual({
+        name: 'my_app.value',
+        type: 'keyword',
+        is_ecs: false,
+      });
+    });
+
     it('produces correct types for a realistic pipeline output', async () => {
       const docs = [
         {

x-pack/platform/plugins/shared/automatic_import/server/services/build_integration/fields.ts

@@ -6,6 +6,7 @@
  */
 
 import type { IFieldsMetadataClient } from '@kbn/fields-metadata-plugin/server/services/fields_metadata/types';
+import type { FieldMapping } from '../../agents/state';
 import type { FieldMappingEntry } from '../saved_objects/saved_objects_service';
 
 interface SampleObj {
@@ -111,7 +112,8 @@ const collectFields = (obj: unknown, parentPath: string): RawField[] => {
  */
 export const generateFieldMappings = async (
   pipelineDocs: Array<Record<string, unknown>>,
-  fieldsMetadataClient: IFieldsMetadataClient
+  fieldsMetadataClient: IFieldsMetadataClient,
+  agentFieldMappings?: FieldMapping[]
 ): Promise<FieldMappingEntry[]> => {
   if (pipelineDocs.length === 0) return [];
 
@@ -126,6 +128,13 @@ export const generateFieldMappings = async (
 
   if (rawFields.length === 0) return [];
 
+  const agentTypeMap = new Map<string, string>();
+  if (agentFieldMappings) {
+    for (const mapping of agentFieldMappings) {
+      agentTypeMap.set(mapping.name, mapping.type);
+    }
+  }
+
   const allFieldNames = rawFields.map((f) => f.name);
   const ecsFieldsDict = await fieldsMetadataClient.find({
     fieldNames: allFieldNames,
@@ -136,9 +145,10 @@ export const generateFieldMappings = async (
   return rawFields.map((f) => {
     const ecsEntry = ecsFieldsMap[f.name];
     const isEcs = !!ecsEntry;
+    const agentType = agentTypeMap.get(f.name);
     return {
       ...f,
-      type: isEcs && ecsEntry.type ? ecsEntry.type : f.type,
+      type: isEcs && ecsEntry.type ? ecsEntry.type : agentType ?? f.type,
       is_ecs: isEcs,
     };
   });

x-pack/platform/plugins/shared/automatic_import/server/services/task_manager/task_manager_service.test.ts

@@ -139,6 +139,10 @@ describe('runTask abort handling', () => {
       invokeAutomaticImportAgent: jest.fn().mockResolvedValue({
         current_pipeline: { name: 'test', processors: [] },
         pipeline_generation_results: [{ _source: { answer: 42 } }],
+        field_mappings: [
+          { name: 'my_app.created_at', type: 'date' },
+          { name: 'my_app.status', type: 'keyword' },
+        ],
       }),
     }));
 
@@ -178,6 +182,18 @@ describe('runTask abort handling', () => {
     );
   });
 
+  it('passes agent field_mappings to generateFieldMappings', async () => {
+    const abortController = new AbortController();
+    const runner = createRunner(abortController);
+
+    await runner.run();
+
+    expect(generateFieldMappings).toHaveBeenCalledWith(expect.any(Array), expect.anything(), [
+      { name: 'my_app.created_at', type: 'date' },
+      { name: 'my_app.status', type: 'keyword' },
+    ]);
+  });
+
   it('marks data stream as cancelled when aborted before agent invocation returns', async () => {
     const abortController = new AbortController();
 
@@ -885,6 +901,26 @@ describe('runTask error edge cases', () => {
     expect(abortController.signal.aborted).toBe(false);
   });
 
+  it('passes undefined agent field_mappings when agent does not provide them', async () => {
+    AgentService.mockImplementation(() => ({
+      invokeAutomaticImportAgent: jest.fn().mockResolvedValue({
+        current_pipeline: { name: 'test', processors: [] },
+        pipeline_generation_results: [{ _source: { value: 'test' } }],
+      }),
+    }));
+
+    buildService();
+    const abortController = new AbortController();
+    const runner = createRunner(abortController);
+    await runner.run();
+
+    expect(generateFieldMappings).toHaveBeenCalledWith(
+      expect.any(Array),
+      expect.anything(),
+      undefined
+    );
+  });
+
   it('passes validation warnings through without failing the task', async () => {
     validateFieldMappings.mockResolvedValue({
       valid: false,

x-pack/platform/plugins/shared/automatic_import/server/services/task_manager/task_manager_service.ts

@@ -28,6 +28,7 @@ import { AgentService } from '../agents/agent_service';
 import type { AutomaticImportSamplesIndexService } from '../samples_index/index_service';
 import { generateFieldMappings } from '../build_integration/fields';
 import { validateFieldMappings } from '../build_integration/validate_fields';
+import type { FieldMapping } from '../../agents/state';
 import type { LangSmithOptions } from '../../routes/types';
 import type { AutomaticImportPluginStartDependencies } from '../../types';
 import type { AutomaticImportSavedObjectService } from '../saved_objects/saved_objects_service';
@@ -277,9 +278,11 @@ export class TaskManagerService {
         `Pipeline generation results objects: ${JSON.stringify(result.pipeline_generation_results)}`
       );
 
+      const agentFieldMappings = (result.field_mappings as FieldMapping[] | undefined) ?? undefined;
       const fieldMapping = await generateFieldMappings(
         (pipelineGenerationResultsObjects ?? []) as Array<Record<string, unknown>>,
-        fieldsMetadataClient
+        fieldsMetadataClient,
+        agentFieldMappings
       );
       this.logger.debug(`Generated field mappings: ${JSON.stringify(fieldMapping)}`);
       this.throwIfAborted(abortSignal);