Improve SDK E2E test assertions

- stream-chunks: Fix vacuous timeSpread >= 0 assertion, make content assertions unconditional
- concurrent-streams: Replace object identity check with proper content validation
- subagent-streaming: Require subagent events instead of silently skipping assertions
- max-agent-steps: Add finish event assertion and new maxAgentSteps=1 test case

Author: brandonkachen

sdk/e2e/streaming/concurrent-streams.e2e.test.ts

@@ -32,7 +32,7 @@ describe('Streaming: Concurrent Streams', () => {
       const collector1 = new EventCollector()
       const collector2 = new EventCollector()
 
-      // Run two prompts concurrently
+      // Run two prompts concurrently with distinctive keywords
       const [result1, result2] = await Promise.all([
         client.run({
           agent: DEFAULT_AGENT,
@@ -58,9 +58,17 @@ describe('Streaming: Concurrent Streams', () => {
       expect(collector2.hasEventType('start')).toBe(true)
       expect(collector2.hasEventType('finish')).toBe(true)
 
-      // Event counts should be independent
-      expect(collector1.events.length).toBeGreaterThan(0)
-      expect(collector2.events.length).toBeGreaterThan(0)
+      // Verify streams contain expected content and aren't mixed
+      const text1 = collector1.getFullStreamText().toUpperCase()
+      const text2 = collector2.getFullStreamText().toUpperCase()
+
+      // Each stream should contain its expected keyword
+      expect(text1).toContain('ALPHA')
+      expect(text2).toContain('BETA')
+
+      // Streams should NOT contain the other stream's keyword (no mixing)
+      expect(text1).not.toContain('BETA')
+      expect(text2).not.toContain('ALPHA')
     },
     DEFAULT_TIMEOUT * 2,
   )
@@ -123,10 +131,26 @@ describe('Streaming: Concurrent Streams', () => {
         }),
       ])
 
-      // Each collector should have independent chunks
-      // The chunks shouldn't be identical (different prompts)
-      // Note: We can't guarantee exact output, but they should be independent
-      expect(collector1.streamChunks).not.toBe(collector2.streamChunks)
+      // Each collector should have independent chunks with different content
+      // Verify both collectors received content
+      expect(collector1.streamChunks.length).toBeGreaterThan(0)
+      expect(collector2.streamChunks.length).toBeGreaterThan(0)
+
+      // Get the full text from each stream
+      const text1 = collector1.getFullStreamText().toUpperCase()
+      const text2 = collector2.getFullStreamText().toUpperCase()
+
+      // Both should have content
+      expect(text1.length).toBeGreaterThan(0)
+      expect(text2.length).toBeGreaterThan(0)
+
+      // Verify each stream contains its expected keyword
+      expect(text1).toContain('FIRST')
+      expect(text2).toContain('SECOND')
+
+      // Verify streams are NOT mixed - each should only have its own content
+      expect(text1).not.toContain('SECOND')
+      expect(text2).not.toContain('FIRST')
     },
     DEFAULT_TIMEOUT * 2,
   )

sdk/e2e/streaming/subagent-streaming.e2e.test.ts

@@ -39,18 +39,20 @@ describe('Streaming: Subagent Streaming', () => {
       const subagentStarts = collector.getEventsByType('subagent_start')
       const subagentFinishes = collector.getEventsByType('subagent_finish')
 
-      // If subagents were spawned, starts and finishes should match
-      if (subagentStarts.length > 0) {
-        // Each started subagent should have a finish
-        for (const start of subagentStarts) {
-          const matchingFinish = subagentFinishes.find(
-            (f) => f.agentId === start.agentId,
-          )
-          // Subagent should eventually finish (or the run ends)
-          expect(start.agentId).toBeDefined()
-          expect(start.agentType).toBeDefined()
-          expect(start.displayName).toBeDefined()
-        }
+      // The prompt should trigger file search which spawns a subagent
+      // If no subagents were spawned, the test isn't validating what we intend
+      expect(subagentStarts.length).toBeGreaterThan(0)
+
+      // Each started subagent should have a finish
+      for (const start of subagentStarts) {
+        const matchingFinish = subagentFinishes.find(
+          (f) => f.agentId === start.agentId,
+        )
+        // Subagent should eventually finish
+        expect(matchingFinish).toBeDefined()
+        expect(start.agentId).toBeDefined()
+        expect(start.agentType).toBeDefined()
+        expect(start.displayName).toBeDefined()
       }
     },
     DEFAULT_TIMEOUT * 2,
@@ -72,6 +74,9 @@ describe('Streaming: Subagent Streaming', () => {
 
       const subagentStarts = collector.getEventsByType('subagent_start')
 
+      // Ensure we actually got subagent events to validate
+      expect(subagentStarts.length).toBeGreaterThan(0)
+
       for (const event of subagentStarts) {
         // Required fields
         expect(typeof event.agentId).toBe('string')
@@ -105,22 +110,26 @@ describe('Streaming: Subagent Streaming', () => {
         cwd: process.cwd(),
       })
 
+      // Verify we got subagent events (prompt should trigger file exploration)
+      const subagentStarts = collector.getEventsByType('subagent_start')
+      expect(subagentStarts.length).toBeGreaterThan(0)
+
       // Check for subagent chunks in stream
       const subagentChunks = collector.streamChunks.filter(
         (c): c is Extract<typeof c, { type: 'subagent_chunk' }> =>
           typeof c !== 'string' && c.type === 'subagent_chunk',
       )
 
-      // If there are subagent events, there might be subagent chunks
-      const subagentStarts = collector.getEventsByType('subagent_start')
-      if (subagentStarts.length > 0 && subagentChunks.length > 0) {
-        // Verify chunk structure
+      // If there are subagent chunks, verify their structure
+      if (subagentChunks.length > 0) {
         for (const chunk of subagentChunks) {
           expect(chunk.agentId).toBeDefined()
           expect(chunk.agentType).toBeDefined()
           expect(typeof chunk.chunk).toBe('string')
         }
       }
+      // Note: Subagent chunks may not always be present even with subagent events
+      // (e.g., if the subagent completes very quickly without streaming)
     },
     DEFAULT_TIMEOUT * 2,
   )
@@ -140,6 +149,9 @@ describe('Streaming: Subagent Streaming', () => {
 
       const subagentStarts = collector.getEventsByType('subagent_start')
 
+      // Ensure we got subagent events to validate uniqueness
+      expect(subagentStarts.length).toBeGreaterThan(0)
+
       // Check for duplicates by agentId
       const agentIds = subagentStarts.map((s) => s.agentId)
       const uniqueIds = new Set(agentIds)