[inference] Merge consecutive same-role messages in OpenAI adapter (elastic#264025)

## Summary

- Adds `mergeConsecutiveMessages` to the OpenAI message conversion layer
(`messagesToOpenAI`), ensuring the LLM always receives strictly
alternating user/assistant messages — matching the behavior already
present in the Gemini adapter.
- Consecutive user messages have their content normalized to
array-of-parts format and combined into a single message. Consecutive
assistant messages have their text joined with newlines and `tool_calls`
arrays merged.
- Tool messages are never merged, since each is tied to a specific
`tool_call_id`.
- Since `messagesToOpenAI` is shared by the `openai`, `inference`, and
`inference_endpoint` adapters, this single change covers all three code
paths.

---------

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

Author: pgayvallet

x-pack/platform/plugins/shared/inference/server/chat_complete/adapters/openai/to_openai.test.ts

@@ -226,4 +226,138 @@ describe('messagesToOpenAI', () => {
       },
     ]);
   });
+
+  describe('message merging', () => {
+    it('merges consecutive user messages into a single message with array content', () => {
+      const result = messagesToOpenAI({
+        messages: [
+          { role: MessageRole.User, content: 'first' },
+          { role: MessageRole.User, content: 'second' },
+        ],
+      });
+
+      expect(result).toEqual([
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'first' },
+            { type: 'text', text: 'second' },
+          ],
+        },
+      ]);
+    });
+
+    it('merges consecutive user messages with mixed string and array content', () => {
+      const result = messagesToOpenAI({
+        messages: [
+          { role: MessageRole.User, content: 'text message' },
+          {
+            role: MessageRole.User,
+            content: [
+              { type: 'image', source: { data: 'base64data', mimeType: 'image/png' } },
+              { type: 'text', text: 'with image' },
+            ],
+          },
+        ],
+      });
+
+      expect(result).toEqual([
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'text message' },
+            { type: 'image_url', image_url: { url: 'base64data' } },
+            { type: 'text', text: 'with image' },
+          ],
+        },
+      ]);
+    });
+
+    it('does not merge non-consecutive same-role messages', () => {
+      const result = messagesToOpenAI({
+        messages: [
+          { role: MessageRole.User, content: 'first' },
+          { role: MessageRole.Assistant, content: 'response' },
+          { role: MessageRole.User, content: 'second' },
+        ],
+      });
+
+      expect(result).toHaveLength(3);
+      expect(result[0]).toEqual({ role: 'user', content: 'first' });
+      expect(result[1]).toEqual(
+        expect.objectContaining({ role: 'assistant', content: 'response' })
+      );
+      expect(result[2]).toEqual({ role: 'user', content: 'second' });
+    });
+
+    it('does not merge consecutive tool messages', () => {
+      const result = messagesToOpenAI({
+        messages: [
+          { role: MessageRole.Tool, name: 'tool', toolCallId: 'call-1', response: { result: 'a' } },
+          { role: MessageRole.Tool, name: 'tool', toolCallId: 'call-2', response: { result: 'b' } },
+        ],
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({
+        role: 'tool',
+        content: '{"result":"a"}',
+        tool_call_id: 'call-1',
+      });
+      expect(result[1]).toEqual({
+        role: 'tool',
+        content: '{"result":"b"}',
+        tool_call_id: 'call-2',
+      });
+    });
+
+    it('merges consecutive assistant messages and combines tool_calls', () => {
+      const result = messagesToOpenAI({
+        messages: [
+          {
+            role: MessageRole.Assistant,
+            content: 'thinking...',
+            toolCalls: [
+              { toolCallId: 'call-1', function: { name: 'tool_a', arguments: { x: 1 } } },
+            ],
+          },
+          {
+            role: MessageRole.Assistant,
+            content: 'more thoughts',
+            toolCalls: [
+              { toolCallId: 'call-2', function: { name: 'tool_b', arguments: { y: 2 } } },
+            ],
+          },
+        ],
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        role: 'assistant',
+        content: 'thinking...\nmore thoughts',
+        tool_calls: [
+          expect.objectContaining({
+            id: 'call-1',
+            function: expect.objectContaining({ name: 'tool_a' }),
+          }),
+          expect.objectContaining({
+            id: 'call-2',
+            function: expect.objectContaining({ name: 'tool_b' }),
+          }),
+        ],
+      });
+    });
+
+    it('does not merge user messages separated by an empty assistant message', () => {
+      const result = messagesToOpenAI({
+        messages: [
+          { role: MessageRole.User, content: 'first' },
+          { role: MessageRole.Assistant, content: '', toolCalls: [] },
+          { role: MessageRole.User, content: 'second' },
+        ],
+      });
+
+      expect(result).toHaveLength(3);
+    });
+  });
 });

x-pack/platform/plugins/shared/inference/server/chat_complete/adapters/openai/to_openai.ts

@@ -129,63 +129,117 @@ export function messagesToOpenAI({
     ? { role: 'system', content: system }
     : undefined;
 
-  return [
-    ...(systemMessage ? [systemMessage] : []),
-    ...messages.map((message): ChatCompletionMessageParam => {
-      const role = message.role;
-
-      switch (role) {
-        case MessageRole.Assistant:
-          const assistantMessage: ChatCompletionAssistantMessageParam = {
-            role: 'assistant',
-            content: message.content ?? '',
-            tool_calls: message.toolCalls?.map((toolCall) => {
-              return {
-                function: {
-                  name: toolCall.function.name,
-                  arguments:
-                    'arguments' in toolCall.function
-                      ? JSON.stringify(toolCall.function.arguments)
-                      : '{}',
-                },
-                id: toolCall.toolCallId,
-                type: 'function',
-              };
-            }),
-          };
-          return assistantMessage;
-
-        case MessageRole.User:
-          const userMessage: ChatCompletionUserMessageParam = {
-            role: 'user',
-            content:
-              typeof message.content === 'string'
-                ? message.content
-                : message.content.map((contentPart) => {
-                    if (contentPart.type === 'image') {
-                      return {
-                        type: 'image_url',
-                        image_url: {
-                          url: contentPart.source.data,
-                        },
-                      } satisfies ChatCompletionContentPartImage;
-                    }
+  const converted = messages.map((message): ChatCompletionMessageParam => {
+    const role = message.role;
+
+    switch (role) {
+      case MessageRole.Assistant:
+        const assistantMessage: ChatCompletionAssistantMessageParam = {
+          role: 'assistant',
+          content: message.content ?? '',
+          tool_calls: message.toolCalls?.map((toolCall) => {
+            return {
+              function: {
+                name: toolCall.function.name,
+                arguments:
+                  'arguments' in toolCall.function
+                    ? JSON.stringify(toolCall.function.arguments)
+                    : '{}',
+              },
+              id: toolCall.toolCallId,
+              type: 'function',
+            };
+          }),
+        };
+        return assistantMessage;
+
+      case MessageRole.User:
+        const userMessage: ChatCompletionUserMessageParam = {
+          role: 'user',
+          content:
+            typeof message.content === 'string'
+              ? message.content
+              : message.content.map((contentPart) => {
+                  if (contentPart.type === 'image') {
                     return {
-                      text: contentPart.text,
-                      type: 'text',
-                    } satisfies ChatCompletionContentPartText;
-                  }),
-          };
-          return userMessage;
-
-        case MessageRole.Tool:
-          const toolMessage: ChatCompletionToolMessageParam = {
-            role: 'tool',
-            content: JSON.stringify(message.response),
-            tool_call_id: message.toolCallId,
-          };
-          return toolMessage;
+                      type: 'image_url',
+                      image_url: {
+                        url: contentPart.source.data,
+                      },
+                    } satisfies ChatCompletionContentPartImage;
+                  }
+                  return {
+                    text: contentPart.text,
+                    type: 'text',
+                  } satisfies ChatCompletionContentPartText;
+                }),
+        };
+        return userMessage;
+
+      case MessageRole.Tool:
+        const toolMessage: ChatCompletionToolMessageParam = {
+          role: 'tool',
+          content: JSON.stringify(message.response),
+          tool_call_id: message.toolCallId,
+        };
+        return toolMessage;
+    }
+  });
+
+  return [...(systemMessage ? [systemMessage] : []), ...mergeConsecutiveMessages(converted)];
+}
+
+/**
+ * Merges consecutive messages with the same role into a single message.
+ * - User messages: content is normalized to array format and parts are concatenated.
+ * - Assistant messages: content strings are joined with newline, tool_calls are combined.
+ * - Tool messages are never merged (each is tied to a specific tool_call_id).
+ * - System messages are not affected (prepended separately).
+ */
+function mergeConsecutiveMessages(
+  messages: ChatCompletionMessageParam[]
+): ChatCompletionMessageParam[] {
+  return messages.reduce<ChatCompletionMessageParam[]>((output, message) => {
+    const previous = output.length ? output[output.length - 1] : undefined;
+
+    if (
+      previous &&
+      previous.role === message.role &&
+      message.role !== 'tool' &&
+      message.role !== 'system'
+    ) {
+      if (message.role === 'user' && previous.role === 'user') {
+        const previousParts = normalizeUserContent(previous.content);
+        const currentParts = normalizeUserContent(message.content);
+        previous.content = [...previousParts, ...currentParts];
+      } else if (message.role === 'assistant' && previous.role === 'assistant') {
+        const prevContent = (previous as ChatCompletionAssistantMessageParam).content ?? '';
+        const curContent = (message as ChatCompletionAssistantMessageParam).content ?? '';
+        (previous as ChatCompletionAssistantMessageParam).content = [prevContent, curContent]
+          .filter(Boolean)
+          .join('\n');
+        const prevCalls = (previous as ChatCompletionAssistantMessageParam).tool_calls;
+        const curCalls = (message as ChatCompletionAssistantMessageParam).tool_calls;
+        if (curCalls?.length) {
+          (previous as ChatCompletionAssistantMessageParam).tool_calls = [
+            ...(prevCalls ?? []),
+            ...curCalls,
+          ];
+        }
       }
-    }),
-  ];
+    } else {
+      output.push(message);
+    }
+
+    return output;
+  }, []);
+}
+
+function normalizeUserContent(
+  content: ChatCompletionUserMessageParam['content']
+): Array<ChatCompletionContentPartText | ChatCompletionContentPartImage> {
+  if (typeof content === 'string') {
+    return [{ type: 'text', text: content }];
+  }
+  return content as Array<ChatCompletionContentPartText | ChatCompletionContentPartImage>;
 }

x-pack/solutions/observability/test/api_integration_deployment_agnostic/apis/ai_assistant/anonymization/anonymization.spec.ts

@@ -108,19 +108,19 @@ export default function ApiTest({ getService }: DeploymentAgnosticFtrProviderCon
 
     it('does not send detected entities to the LLM via chat/complete', async () => {
       const userMsgsReq = simulator.requestBody.messages.filter((m: any) => m.role === 'user');
-      expect(userMsgsReq).to.have.length(2);
-      // First message
-      const firstMsgReq = userMsgsReq[0].content;
-      expect(firstMsgReq).to.not.contain('claudia@example.com');
-      expect(
-        typeof firstMsgReq === 'string' && (firstMsgReq.match(/[0-9a-f]{40}/g) || []).length
-      ).to.be(1);
-      // Second message
-      const secMsgReq = userMsgsReq[1].content;
-      expect(secMsgReq).to.not.contain('http://claudia.is');
-      expect(
-        typeof secMsgReq === 'string' && (secMsgReq.match(/[0-9a-f]{40}/g) || []).length
-      ).to.be(1);
+      // Consecutive user messages are merged into a single message with array content
+      expect(userMsgsReq).to.have.length(1);
+      const contentParts = userMsgsReq[0].content!;
+      expect(contentParts).to.be.an('array');
+      expect(contentParts).to.have.length(2);
+      // First content part (email anonymized)
+      const firstPart = (contentParts[0] as { text: string }).text;
+      expect(firstPart).to.not.contain('claudia@example.com');
+      expect((firstPart.match(/[0-9a-f]{40}/g) || []).length).to.be(1);
+      // Second content part (URL anonymized)
+      const secPart = (contentParts[1] as { text: string }).text;
+      expect(secPart).to.not.contain('http://claudia.is');
+      expect((secPart.match(/[0-9a-f]{40}/g) || []).length).to.be(1);
     });
 
     it('stores deanonymized messages and deanonymizations in Elasticsearch', async () => {