test(conversations): Consolidate redundant turn and reasoning tests

Merge the three agentName tests and two modelName tests into two
attribute-driven cases via an assistantFromAttributes helper, and drop
reasoning assertions that were duplicated across the parse, turn, and
integration layers. Reasoning is now covered once at the unit (parse) layer,
once at the turn layer, and via the markdown-exclusion test.

Refs TET-2453
Co-Authored-By: Claude <noreply@anthropic.com>

Author: Ognjen Bostjancic

static/app/views/explore/conversations/utils/conversationMessages.spec.ts

@@ -728,101 +728,42 @@ describe('conversationMessages utilities', () => {
       expect(assistantMessages).toHaveLength(2);
     });
 
-    it('includes agentName from gen_ai.agent.name', () => {
+    function assistantFromAttributes(attributes: Record<string, string>) {
       const turns = [
         makeTurn({
           generation: {
             id: 'gen-1',
             value: {start_timestamp: 1000, end_timestamp: 1100},
-            attributes: {
-              [SpanFields.GEN_AI_AGENT_NAME]: 'my-agent',
-            },
-          } as any,
-          userContent: 'Hello',
-          assistantContent: 'Hi',
-        }),
-      ];
-
-      const messages = turnsToMessages(turns);
-      const assistant = messages.find(m => m.role === 'assistant');
-      expect(assistant?.agentName).toBe('my-agent');
-    });
-
-    it('falls back agentName to gen_ai.function_id', () => {
-      const turns = [
-        makeTurn({
-          generation: {
-            id: 'gen-1',
-            value: {start_timestamp: 1000, end_timestamp: 1100},
-            attributes: {
-              [SpanFields.GEN_AI_FUNCTION_ID]: 'vercel-func',
-            },
-          } as any,
-          userContent: 'Hello',
-          assistantContent: 'Hi',
-        }),
-      ];
-
-      const messages = turnsToMessages(turns);
-      const assistant = messages.find(m => m.role === 'assistant');
-      expect(assistant?.agentName).toBe('vercel-func');
-    });
-
-    it('prefers gen_ai.agent.name over gen_ai.function_id for agentName', () => {
-      const turns = [
-        makeTurn({
-          generation: {
-            id: 'gen-1',
-            value: {start_timestamp: 1000, end_timestamp: 1100},
-            attributes: {
-              [SpanFields.GEN_AI_AGENT_NAME]: 'preferred-agent',
-              [SpanFields.GEN_AI_FUNCTION_ID]: 'fallback-func',
-            },
-          } as any,
-          userContent: 'Hello',
-          assistantContent: 'Hi',
-        }),
-      ];
-
-      const messages = turnsToMessages(turns);
-      const assistant = messages.find(m => m.role === 'assistant');
-      expect(assistant?.agentName).toBe('preferred-agent');
-    });
-
-    it('includes modelName from gen_ai.response.model', () => {
-      const turns = [
-        makeTurn({
-          generation: {
-            id: 'gen-1',
-            value: {start_timestamp: 1000, end_timestamp: 1100},
-            attributes: {
-              [SpanFields.GEN_AI_RESPONSE_MODEL]: 'gpt-4o',
-            },
+            attributes,
           } as any,
           userContent: 'Hello',
           assistantContent: 'Hi',
         }),
       ];
-
-      const messages = turnsToMessages(turns);
-      const assistant = messages.find(m => m.role === 'assistant');
-      expect(assistant?.modelName).toBe('gpt-4o');
-    });
-
-    it('leaves agentName and modelName undefined when not set', () => {
-      const turns = [
-        makeTurn({
-          generation: {
-            id: 'gen-1',
-            value: {start_timestamp: 1000, end_timestamp: 1100},
-          } as any,
-          userContent: 'Hello',
-          assistantContent: 'Hi',
-        }),
-      ];
-
-      const messages = turnsToMessages(turns);
-      const assistant = messages.find(m => m.role === 'assistant');
+      return turnsToMessages(turns).find(m => m.role === 'assistant');
+    }
+
+    it('resolves agentName from agent.name, then function_id, preferring agent.name', () => {
+      expect(
+        assistantFromAttributes({[SpanFields.GEN_AI_AGENT_NAME]: 'my-agent'})?.agentName
+      ).toBe('my-agent');
+      expect(
+        assistantFromAttributes({[SpanFields.GEN_AI_FUNCTION_ID]: 'vercel-func'})
+          ?.agentName
+      ).toBe('vercel-func');
+      expect(
+        assistantFromAttributes({
+          [SpanFields.GEN_AI_AGENT_NAME]: 'preferred-agent',
+          [SpanFields.GEN_AI_FUNCTION_ID]: 'fallback-func',
+        })?.agentName
+      ).toBe('preferred-agent');
+    });
+
+    it('resolves modelName from gen_ai.response.model, undefined when unset', () => {
+      expect(
+        assistantFromAttributes({[SpanFields.GEN_AI_RESPONSE_MODEL]: 'gpt-4o'})?.modelName
+      ).toBe('gpt-4o');
+      const assistant = assistantFromAttributes({});
       expect(assistant?.agentName).toBeUndefined();
       expect(assistant?.modelName).toBeUndefined();
     });
@@ -961,20 +902,6 @@ describe('conversationMessages utilities', () => {
       const assistant = turnsToMessages(turns).find(m => m.role === 'assistant');
       expect(assistant?.reasoning).toBe('Let me think step by step...');
     });
-
-    it('attaches reasoning to tool-call-only turns without text', () => {
-      const turns = [
-        makeTurn({
-          userContent: 'Question',
-          toolCalls: [{name: 'search', nodeId: 'tool-1', hasError: false}],
-          reasoning: 'Thinking out loud',
-        }),
-      ];
-
-      const assistant = turnsToMessages(turns).find(m => m.role === 'assistant');
-      expect(assistant?.content).toBe('');
-      expect(assistant?.reasoning).toBe('Thinking out loud');
-    });
   });
 
   describe('extractMessagesFromNodes (integration)', () => {
@@ -1211,34 +1138,6 @@ describe('conversationMessages utilities', () => {
     });
   });
 
-  describe('reasoning in extractMessagesFromNodes', () => {
-    it('includes reasoning on assistant messages', () => {
-      const outputMessages = JSON.stringify([
-        {
-          role: 'assistant',
-          parts: [
-            {type: 'reasoning', content: 'Thinking...'},
-            {type: 'text', text: 'Answer'},
-          ],
-        },
-      ]);
-      const inputMessages = JSON.stringify([{role: 'user', content: 'Question'}]);
-      const node = createMockNode({
-        id: 'span-1',
-        startTimestamp: 1000,
-        attributes: {
-          [SpanFields.GEN_AI_INPUT_MESSAGES]: inputMessages,
-          [SpanFields.GEN_AI_OUTPUT_MESSAGES]: outputMessages,
-        },
-      });
-
-      const messages = extractMessagesFromNodes([node as any]);
-      const assistant = messages.find(m => m.role === 'assistant');
-      expect(assistant?.content).toBe('Answer');
-      expect(assistant?.reasoning).toBe('Thinking...');
-    });
-  });
-
   describe('messagesToMarkdown', () => {
     it('formats user messages with email', () => {
       const result = messagesToMarkdown([