@librechat/agents 3.4.7 → 3.5.0

package/src/messages/labelContentByAgent.test.ts

@@ -1,962 +0,0 @@
-import type { MessageContentComplex, ToolCallContent } from '@/types';
-import { labelContentByAgent } from './format';
-import { ContentTypes } from '@/common';
-
-/**
- * Type guard to check if content is ToolCallContent
- */
-function isToolCallContent(
-  content: MessageContentComplex
-): content is ToolCallContent {
-  return content.type === ContentTypes.TOOL_CALL && 'tool_call' in content;
-}
-
-/**
- * Type guard to check if content has text property
- */
-function hasTextProperty(
-  content: MessageContentComplex
-): content is MessageContentComplex & { text: string } {
-  return 'text' in content;
-}
-
-describe('labelContentByAgent', () => {
-  describe('Basic functionality', () => {
-    it('should return contentParts unchanged when no agentIdMap provided', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Hello world' },
-      ];
-
-      const result = labelContentByAgent(contentParts, undefined);
-
-      expect(result).toEqual(contentParts);
-      expect(result.length).toBe(1);
-    });
-
-    it('should return contentParts unchanged when agentIdMap is empty', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Hello world' },
-      ];
-
-      const result = labelContentByAgent(contentParts, {});
-
-      expect(result).toEqual(contentParts);
-      expect(result.length).toBe(1);
-    });
-
-    it('should handle empty contentParts array', () => {
-      const contentParts: MessageContentComplex[] = [];
-      const agentIdMap = {};
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('steer pass-through', () => {
-    it('passes steer parts through the parallel labeler verbatim', () => {
-      const steerPart = {
-        type: ContentTypes.STEER,
-        steer: 'User redirect mid-run',
-        steerId: 's1',
-      } as unknown as MessageContentComplex;
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'agent output' },
-        steerPart,
-        { type: ContentTypes.TEXT, text: 'post-steer output' },
-      ];
-
-      const result = labelContentByAgent(
-        contentParts,
-        { 0: 'agent_a', 1: 'agent_a', 2: 'agent_a' },
-        { agent_a: 'Alpha' },
-        { labelNonTransferContent: true }
-      );
-
-      // The user's words survive verbatim (not folded into a labeled
-      // summary) so formatAssistantMessage can replay them as a user turn.
-      expect(result).toContain(steerPart);
-    });
-  });
-
-  describe('steer vs transfer capture', () => {
-    it('closes an open transfer capture at a steer boundary', () => {
-      const transferPart: MessageContentComplex = {
-        type: ContentTypes.TOOL_CALL,
-        tool_call: {
-          id: 'call_transfer',
-          name: 'lc_transfer_to_beta',
-          args: '{}',
-          output: 'original output',
-        },
-      } as MessageContentComplex;
-      const steerPart = {
-        type: ContentTypes.STEER,
-        steer: 'Actually, stop and summarize.',
-      } as unknown as MessageContentComplex;
-      const contentParts: MessageContentComplex[] = [
-        transferPart,
-        steerPart,
-        { type: ContentTypes.TEXT, text: 'post-steer agent output' },
-      ];
-
-      const result = labelContentByAgent(
-        contentParts,
-        { 0: 'agent_a', 1: 'agent_a', 2: 'agent_b' },
-        { agent_b: 'Beta' }
-      );
-
-      // The steer passes through and post-steer content stays AFTER it —
-      // never folded into the pre-steer transfer output, which would replay
-      // it ahead of the user's redirect.
-      expect(result).toContain(steerPart);
-      const transferInResult = result.find(
-        (part) =>
-          isToolCallContent(part) && part.tool_call?.id === 'call_transfer'
-      );
-      expect(
-        isToolCallContent(transferInResult!)
-          ? transferInResult.tool_call?.output
-          : undefined
-      ).toBe('original output');
-      const steerIndex = result.indexOf(steerPart);
-      const textIndex = result.findIndex(
-        (part) =>
-          hasTextProperty(part) && part.text === 'post-steer agent output'
-      );
-      expect(textIndex).toBeGreaterThan(steerIndex);
-    });
-  });
-
-  describe('Transfer-based labeling (default)', () => {
-    it('should consolidate transferred agent content into transfer tool output', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: '' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'call_123',
-            name: 'lc_transfer_to_specialist',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Specialist response here' },
-      ];
-
-      const agentIdMap = {
-        0: 'supervisor',
-        1: 'supervisor',
-        2: 'specialist',
-      };
-
-      const agentNames = {
-        supervisor: 'Supervisor',
-        specialist: 'Specialist Agent',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, agentNames);
-
-      // Should have 2 items: empty text + modified transfer tool call
-      expect(result.length).toBe(2);
-      expect(result[0].type).toBe(ContentTypes.TEXT);
-
-      // The transfer tool call should have consolidated output
-      expect(result[1].type).toBe(ContentTypes.TOOL_CALL);
-      const toolCallContent = result[1] as ToolCallContent;
-      expect(toolCallContent.tool_call?.output).toContain(
-        '--- Transfer to Specialist Agent ---'
-      );
-      expect(toolCallContent.tool_call?.output).toContain('"type":"text"');
-      expect(toolCallContent.tool_call?.output).toContain(
-        '"text":"Specialist response here"'
-      );
-      expect(toolCallContent.tool_call?.output).toContain(
-        '--- End of Specialist Agent response ---'
-      );
-    });
-
-    it('should handle multiple content types from transferred agent', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_1',
-            name: 'lc_transfer_to_analyst',
-            args: '',
-          },
-        },
-        { type: ContentTypes.THINK, think: 'Analyzing the problem...' },
-        { type: ContentTypes.TEXT, text: 'Here is my analysis' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'tool_1',
-            name: 'search',
-            args: '{"query":"test"}',
-          },
-        },
-      ];
-
-      const agentIdMap = {
-        0: 'supervisor',
-        1: 'analyst',
-        2: 'analyst',
-        3: 'analyst',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(result.length).toBe(1);
-      expect(isToolCallContent(result[0])).toBe(true);
-      if (isToolCallContent(result[0])) {
-        expect(result[0].tool_call?.output).toContain('"type":"think"');
-        expect(result[0].tool_call?.output).toContain('"type":"text"');
-        expect(result[0].tool_call?.output).toContain('"type":"tool_call"');
-        expect(result[0].tool_call?.output).toContain(
-          'Analyzing the problem...'
-        );
-        expect(result[0].tool_call?.output).toContain('Here is my analysis');
-      }
-    });
-
-    it('should use agentId when agentNames not provided', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'call_1',
-            name: 'lc_transfer_to_agent2',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Response from agent2' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent2',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(isToolCallContent(result[0])).toBe(true);
-      if (isToolCallContent(result[0])) {
-        expect(result[0].tool_call?.output).toContain(
-          '--- Transfer to agent2 ---'
-        );
-        expect(result[0].tool_call?.output).toContain('agent2:');
-      }
-    });
-
-    it('should handle sequential transfers (agent1 -> agent2 -> agent3)', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Starting' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_1',
-            name: 'lc_transfer_to_agent2',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Agent2 response' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_2',
-            name: 'lc_transfer_to_agent3',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Agent3 final response' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent1',
-        2: 'agent2',
-        3: 'agent2',
-        4: 'agent3',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(result.length).toBe(3);
-      expect(result[0].type).toBe(ContentTypes.TEXT);
-      expect(result[1].type).toBe(ContentTypes.TOOL_CALL);
-      expect(result[2].type).toBe(ContentTypes.TOOL_CALL);
-
-      // First transfer should have agent2 content
-      if (isToolCallContent(result[1])) {
-        expect(result[1].tool_call?.output).toContain('agent2');
-        expect(result[1].tool_call?.output).toContain('Agent2 response');
-      }
-
-      // Second transfer should have agent3 content
-      if (isToolCallContent(result[2])) {
-        expect(result[2].tool_call?.output).toContain('agent3');
-        expect(result[2].tool_call?.output).toContain('Agent3 final response');
-      }
-    });
-  });
-
-  describe('Full agent labeling (labelNonTransferContent: true)', () => {
-    it('should label all agent content when labelNonTransferContent is true', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Researcher coordinating' },
-        { type: ContentTypes.TEXT, text: 'FINANCIAL ANALYSIS: Revenue impact' },
-        {
-          type: ContentTypes.TEXT,
-          text: 'TECHNICAL ANALYSIS: System requirements',
-        },
-        { type: ContentTypes.TEXT, text: 'Summary of all analyses' },
-      ];
-
-      const agentIdMap = {
-        0: 'researcher',
-        1: 'analyst1',
-        2: 'analyst2',
-        3: 'summarizer',
-      };
-
-      const agentNames = {
-        researcher: 'Research Coordinator',
-        analyst1: 'Financial Analyst',
-        analyst2: 'Technical Analyst',
-        summarizer: 'Synthesis Expert',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, agentNames, {
-        labelNonTransferContent: true,
-      });
-
-      // Should create 4 labeled groups
-      expect(result.length).toBe(4);
-
-      // Each should be a text content part with agent labels
-      expect(result[0].type).toBe(ContentTypes.TEXT);
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('--- Research Coordinator ---');
-        expect(result[0].text).toContain(
-          'Research Coordinator: Researcher coordinating'
-        );
-        expect(result[0].text).toContain('--- End of Research Coordinator ---');
-      }
-
-      expect(result[1].type).toBe(ContentTypes.TEXT);
-      if (hasTextProperty(result[1])) {
-        expect(result[1].text).toContain('--- Financial Analyst ---');
-        expect(result[1].text).toContain(
-          'Financial Analyst: FINANCIAL ANALYSIS: Revenue impact'
-        );
-      }
-
-      expect(result[2].type).toBe(ContentTypes.TEXT);
-      if (hasTextProperty(result[2])) {
-        expect(result[2].text).toContain('--- Technical Analyst ---');
-        expect(result[2].text).toContain(
-          'Technical Analyst: TECHNICAL ANALYSIS: System requirements'
-        );
-      }
-
-      expect(result[3].type).toBe(ContentTypes.TEXT);
-      if (hasTextProperty(result[3])) {
-        expect(result[3].text).toContain('--- Synthesis Expert ---');
-        expect(result[3].text).toContain(
-          'Synthesis Expert: Summary of all analyses'
-        );
-      }
-    });
-
-    it('should group consecutive content from same agent', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'First message' },
-        { type: ContentTypes.TEXT, text: 'Second message' },
-        { type: ContentTypes.TEXT, text: 'Third message' },
-        { type: ContentTypes.TEXT, text: 'Different agent' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent1',
-        2: 'agent1',
-        3: 'agent2',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      // Should create 2 groups
-      expect(result.length).toBe(2);
-
-      // First group has all 3 messages from agent1
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('agent1: First message');
-        expect(result[0].text).toContain('agent1: Second message');
-        expect(result[0].text).toContain('agent1: Third message');
-      }
-
-      // Second group has agent2 message
-      if (hasTextProperty(result[1])) {
-        expect(result[1].text).toContain('agent2: Different agent');
-      }
-    });
-
-    it('should handle thinking content in parallel labeling', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.THINK, think: 'Let me analyze this...' },
-        { type: ContentTypes.TEXT, text: 'My conclusion' },
-      ];
-
-      const agentIdMap = {
-        0: 'analyst',
-        1: 'analyst',
-      };
-
-      const agentNames = {
-        analyst: 'Expert Analyst',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, agentNames, {
-        labelNonTransferContent: true,
-      });
-
-      expect(result.length).toBe(1);
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('--- Expert Analyst ---');
-        expect(result[0].text).toContain('"type":"think"');
-        expect(result[0].text).toContain('Let me analyze this...');
-        expect(result[0].text).toContain('Expert Analyst: My conclusion');
-      }
-    });
-
-    it('should skip empty text content in parallel labeling', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: '' },
-        { type: ContentTypes.TEXT, text: 'Valid content' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent1',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      expect(result.length).toBe(1);
-      // Should only contain the valid content, not the empty string
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('agent1: Valid content');
-        expect(result[0].text).not.toContain('agent1: \n');
-      }
-    });
-  });
-
-  describe('Edge cases', () => {
-    it('should handle content parts without agentId in map', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Message 1' },
-        { type: ContentTypes.TEXT, text: 'Message 2' },
-        { type: ContentTypes.TEXT, text: 'Message 3' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        // Missing index 1
-        2: 'agent2',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      // Should still process and group by available agent IDs
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('should handle transfer tool without subsequent agent content', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_1',
-            name: 'lc_transfer_to_specialist',
-            args: '',
-          },
-        },
-      ];
-
-      const agentIdMap = {
-        0: 'supervisor',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      // Transfer tool should still be present, just without added content
-      expect(result.length).toBe(1);
-      expect(result[0].type).toBe(ContentTypes.TOOL_CALL);
-    });
-
-    it('should handle multiple transfers in sequence', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_1',
-            name: 'lc_transfer_to_agent_a',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Agent A response' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_2',
-            name: 'lc_transfer_to_agent_b',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Agent B response' },
-      ];
-
-      const agentIdMap = {
-        0: 'supervisor',
-        1: 'agent_a',
-        2: 'agent_a',
-        3: 'agent_b',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(result.length).toBe(2);
-
-      // Both transfers should have consolidated outputs
-      if (isToolCallContent(result[0])) {
-        expect(result[0].tool_call?.output).toContain('agent_a');
-        expect(result[0].tool_call?.output).toContain('Agent A response');
-      }
-
-      if (isToolCallContent(result[1])) {
-        expect(result[1].tool_call?.output).toContain('agent_b');
-        expect(result[1].tool_call?.output).toContain('Agent B response');
-      }
-    });
-
-    it('should preserve non-transfer tool calls unchanged', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Using a tool' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'tool_1',
-            name: 'search',
-            args: '{"query":"test"}',
-            output: 'Search results',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Here are the results' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent1',
-        2: 'agent1',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      // All content from same agent with no transfers, should pass through
-      expect(result).toEqual(contentParts);
-    });
-  });
-
-  describe('Parallel patterns', () => {
-    it('should label parallel analyst contributions separately', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Coordinating research' },
-        { type: ContentTypes.TEXT, text: 'FINANCIAL: Budget analysis' },
-        { type: ContentTypes.TEXT, text: 'TECHNICAL: System design' },
-        { type: ContentTypes.TEXT, text: 'MARKET: Competitive landscape' },
-        { type: ContentTypes.TEXT, text: 'Integrated summary' },
-      ];
-
-      const agentIdMap = {
-        0: 'researcher',
-        1: 'financial_analyst',
-        2: 'technical_analyst',
-        3: 'market_analyst',
-        4: 'summarizer',
-      };
-
-      const agentNames = {
-        researcher: 'Research Coordinator',
-        financial_analyst: 'Financial Analyst',
-        technical_analyst: 'Technical Analyst',
-        market_analyst: 'Market Analyst',
-        summarizer: 'Synthesis Expert',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, agentNames, {
-        labelNonTransferContent: true,
-      });
-
-      // Should have 5 labeled groups (one per agent)
-      expect(result.length).toBe(5);
-
-      // Verify each group
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('--- Research Coordinator ---');
-        expect(result[0].text).toContain('Coordinating research');
-      }
-
-      if (hasTextProperty(result[1])) {
-        expect(result[1].text).toContain('--- Financial Analyst ---');
-        expect(result[1].text).toContain('FINANCIAL: Budget analysis');
-      }
-
-      if (hasTextProperty(result[2])) {
-        expect(result[2].text).toContain('--- Technical Analyst ---');
-        expect(result[2].text).toContain('TECHNICAL: System design');
-      }
-
-      if (hasTextProperty(result[3])) {
-        expect(result[3].text).toContain('--- Market Analyst ---');
-        expect(result[3].text).toContain('MARKET: Competitive landscape');
-      }
-
-      if (hasTextProperty(result[4])) {
-        expect(result[4].text).toContain('--- Synthesis Expert ---');
-        expect(result[4].text).toContain('Integrated summary');
-      }
-    });
-
-    it('should handle agent alternation in parallel mode', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'A1' },
-        { type: ContentTypes.TEXT, text: 'B1' },
-        { type: ContentTypes.TEXT, text: 'A2' },
-        { type: ContentTypes.TEXT, text: 'B2' },
-      ];
-
-      const agentIdMap = {
-        0: 'agentA',
-        1: 'agentB',
-        2: 'agentA',
-        3: 'agentB',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      // Should create 4 groups (alternating agents)
-      expect(result.length).toBe(4);
-
-      if (hasTextProperty(result[0]))
-        expect(result[0].text).toContain('agentA: A1');
-      if (hasTextProperty(result[1]))
-        expect(result[1].text).toContain('agentB: B1');
-      if (hasTextProperty(result[2]))
-        expect(result[2].text).toContain('agentA: A2');
-      if (hasTextProperty(result[3]))
-        expect(result[3].text).toContain('agentB: B2');
-    });
-
-    it('should handle tool calls in parallel labeling', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Analyzing' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'tool_1',
-            name: 'search',
-            args: '{"query":"data"}',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Results analyzed' },
-      ];
-
-      const agentIdMap = {
-        0: 'analyst',
-        1: 'analyst',
-        2: 'analyst',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      expect(result.length).toBe(1);
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('--- analyst ---');
-        expect(result[0].text).toContain('analyst: Analyzing');
-        expect(result[0].text).toContain('"type":"tool_call"');
-        expect(result[0].text).toContain('"name":"search"');
-        expect(result[0].text).toContain('analyst: Results analyzed');
-      }
-    });
-  });
-
-  describe('Mixed patterns', () => {
-    it('should handle content with no transfer but mixed agents (without option)', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Agent 1 says this' },
-        { type: ContentTypes.TEXT, text: 'Agent 2 says this' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent2',
-      };
-
-      // Default mode (transfer-based) should pass through non-transfer content
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(result).toEqual(contentParts);
-    });
-
-    it('should handle hybrid: transfer followed by non-transfer agents', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'transfer_1',
-            name: 'lc_transfer_to_specialist',
-            args: '',
-          },
-        },
-        { type: ContentTypes.TEXT, text: 'Specialist work' },
-        { type: ContentTypes.TEXT, text: 'Another agent response' },
-      ];
-
-      const agentIdMap = {
-        0: 'supervisor',
-        1: 'specialist',
-        2: 'agent3',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap);
-
-      expect(result.length).toBe(2);
-
-      // Transfer tool should have specialist content
-      if (isToolCallContent(result[0])) {
-        expect(result[0].tool_call?.output).toContain('specialist');
-        expect(result[0].tool_call?.output).toContain('Specialist work');
-      }
-
-      // Non-transfer content should pass through
-      expect(result[1]).toEqual(contentParts[2]);
-    });
-  });
-
-  describe('Real-world scenarios', () => {
-    it('should handle supervisor -> legal_advisor handoff pattern', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: '' },
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'call_legal',
-            name: 'lc_transfer_to_legal_advisor',
-            args: '',
-          },
-        },
-        {
-          type: ContentTypes.TEXT,
-          text: 'GPL licensing creates obligations...',
-        },
-      ];
-
-      const agentIdMap = {
-        0: 'supervisor',
-        1: 'supervisor',
-        2: 'legal_advisor',
-      };
-
-      const agentNames = {
-        supervisor: 'Supervisor',
-        legal_advisor: 'Legal Advisor',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, agentNames);
-
-      expect(result.length).toBe(2);
-      if (isToolCallContent(result[1])) {
-        expect(result[1].tool_call?.output).toContain(
-          '--- Transfer to Legal Advisor ---'
-        );
-        expect(result[1].tool_call?.output).toContain('"type":"text"');
-        expect(result[1].tool_call?.output).toContain(
-          '"text":"GPL licensing creates obligations..."'
-        );
-        expect(result[1].tool_call?.output).toContain(
-          '--- End of Legal Advisor response ---'
-        );
-      }
-    });
-
-    it('should handle fan-out to 3 analysts then fan-in to summarizer', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Coordination brief' },
-        { type: ContentTypes.TEXT, text: 'Financial analysis content' },
-        { type: ContentTypes.TEXT, text: 'Technical analysis content' },
-        { type: ContentTypes.TEXT, text: 'Market analysis content' },
-        { type: ContentTypes.TEXT, text: 'Executive summary' },
-      ];
-
-      const agentIdMap = {
-        0: 'researcher',
-        1: 'analyst1',
-        2: 'analyst2',
-        3: 'analyst3',
-        4: 'summarizer',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      expect(result.length).toBe(5);
-
-      // Each analyst's work should be clearly separated
-      if (hasTextProperty(result[0]))
-        expect(result[0].text).toContain('researcher:');
-      if (hasTextProperty(result[1]))
-        expect(result[1].text).toContain('analyst1:');
-      if (hasTextProperty(result[2]))
-        expect(result[2].text).toContain('analyst2:');
-      if (hasTextProperty(result[3]))
-        expect(result[3].text).toContain('analyst3:');
-      if (hasTextProperty(result[4]))
-        expect(result[4].text).toContain('summarizer:');
-    });
-  });
-
-  describe('Performance and edge cases', () => {
-    it('should handle large number of content parts efficiently', () => {
-      const contentParts: MessageContentComplex[] = [];
-      const agentIdMap: Record<number, string> = {};
-
-      // Create 100 content parts from 10 different agents
-      for (let i = 0; i < 100; i++) {
-        contentParts.push({
-          type: ContentTypes.TEXT,
-          text: `Message ${i}`,
-        });
-        agentIdMap[i] = `agent${i % 10}`;
-      }
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      // Should complete without errors
-      expect(result.length).toBeGreaterThan(0);
-      expect(result.length).toBeLessThanOrEqual(100);
-    });
-
-    it('should handle all content from single agent', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Part 1' },
-        { type: ContentTypes.TEXT, text: 'Part 2' },
-        { type: ContentTypes.TEXT, text: 'Part 3' },
-      ];
-
-      const agentIdMap = {
-        0: 'single_agent',
-        1: 'single_agent',
-        2: 'single_agent',
-      };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      // Should create 1 group with all content
-      expect(result.length).toBe(1);
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('single_agent: Part 1');
-        expect(result[0].text).toContain('single_agent: Part 2');
-        expect(result[0].text).toContain('single_agent: Part 3');
-      }
-    });
-  });
-
-  describe('Content type handling', () => {
-    it('should properly format thinking content with JSON', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.THINK,
-          think: 'I need to consider multiple factors...',
-        },
-      ];
-
-      const agentIdMap = { 0: 'analyst' };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      if (hasTextProperty(result[0])) {
-        const parsed = JSON.parse(
-          result[0].text.split('analyst: ')[1].split('\n')[0]
-        );
-        expect(parsed.type).toBe('think');
-        expect(parsed.think).toBe('I need to consider multiple factors...');
-      }
-    });
-
-    it('should properly format tool call content with JSON', () => {
-      const contentParts: MessageContentComplex[] = [
-        {
-          type: ContentTypes.TOOL_CALL,
-          tool_call: {
-            id: 'tool_123',
-            name: 'calculator',
-            args: { expression: '2+2' },
-            output: '4',
-          },
-        },
-      ];
-
-      const agentIdMap = { 0: 'agent1' };
-
-      const result = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      if (hasTextProperty(result[0])) {
-        expect(result[0].text).toContain('"type":"tool_call"');
-        expect(result[0].text).toContain('"name":"calculator"');
-        expect(result[0].text).toContain('"id":"tool_123"');
-      }
-    });
-  });
-
-  describe('Integration scenarios', () => {
-    it('should work with formatAgentMessages pipeline', () => {
-      const contentParts: MessageContentComplex[] = [
-        { type: ContentTypes.TEXT, text: 'Agent 1 content' },
-        { type: ContentTypes.TEXT, text: 'Agent 2 content' },
-      ];
-
-      const agentIdMap = {
-        0: 'agent1',
-        1: 'agent2',
-      };
-
-      const labeled = labelContentByAgent(contentParts, agentIdMap, undefined, {
-        labelNonTransferContent: true,
-      });
-
-      // Labeled content should be valid for formatAgentMessages
-      expect(labeled.length).toBeGreaterThan(0);
-      expect(labeled.every((part) => part.type != null)).toBe(true);
-    });
-  });
-});