@illuma-ai/agents 1.0.89 → 1.0.93

package/src/messages/labelContentByAgent.test.js

@@ -0,0 +1,725 @@
+import { ContentTypes } from '@/common';
+import { labelContentByAgent } from './format';
+/**
+ * Type guard to check if content is ToolCallContent
+ */
+function isToolCallContent(content) {
+    return content.type === ContentTypes.TOOL_CALL && 'tool_call' in content;
+}
+/**
+ * Type guard to check if content has text property
+ */
+function hasTextProperty(content) {
+    return 'text' in content;
+}
+describe('labelContentByAgent', () => {
+    describe('Basic functionality', () => {
+        it('should return contentParts unchanged when no agentIdMap provided', () => {
+            const contentParts = [
+                { 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 = [
+                { 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 = [];
+            const agentIdMap = {};
+            const result = labelContentByAgent(contentParts, agentIdMap);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('Transfer-based labeling (default)', () => {
+        it('should consolidate transferred agent content into transfer tool output', () => {
+            const contentParts = [
+                { 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];
+            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 = [
+                {
+                    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 = [
+                {
+                    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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                {
+                    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 = [
+                {
+                    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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                { 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 = [
+                {
+                    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 = [
+                { 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 = [
+                { 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 = [];
+            const agentIdMap = {};
+            // 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 = [
+                { 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 = [
+                {
+                    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 = [
+                {
+                    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 = [
+                { 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);
+        });
+    });
+});
+//# sourceMappingURL=labelContentByAgent.test.js.map