fix: call clearScope on error path in Vercel decoder

The lifecycle tracker's clearScope was called on finish and abort but
not on error. If error is the terminal event in a turn (no subsequent
finish), the scope entry leaks. clearScope is idempotent so adding it
defensively is harmless.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: JoaoDiasAbly

src/vercel/codec/decoder.ts

@@ -277,7 +277,8 @@ const decodeFinish = (r: VercelHeaderReader, turnId: string, lifecycle: Lifecycl
   );
 };
 
-const decodeError = (data: unknown): Out[] => {
+const decodeError = (data: unknown, turnId: string, lifecycle: LifecycleTracker<AI.UIMessageChunk>): Out[] => {
+  lifecycle.clearScope(turnId);
   const errorText = typeof data === 'string' ? data : '';
   return event({ type: 'error', errorText });
 };
@@ -523,7 +524,7 @@ const decodeDiscretePayload = (input: MessagePayload, lifecycle: LifecycleTracke
       return decodeFinish(r, turnId, lifecycle);
     }
     case 'error': {
-      return decodeError(input.data);
+      return decodeError(input.data, turnId, lifecycle);
     }
     case 'abort': {
       return decodeAbort(input.data, turnId, lifecycle);

test/vercel/codec/decoder.test.ts

@@ -681,6 +681,132 @@ describe('Vercel decoder', () => {
       expect(eventTypesOf(outputs)).toContain('start-step');
       expect(eventTypesOf(outputs)).not.toContain('start'); // start already emitted for this turn
     });
+
+    it('clears lifecycle scope after finish', () => {
+      const decoder = createDecoder();
+
+      // Stream content — synthesizes start + start-step
+      decoder.decode(
+        withHeaders(
+          { action: 'message.create', serial: 's1', name: 'text', data: '' },
+          {
+            [HEADER_STREAM]: 'true',
+            [HEADER_STATUS]: 'streaming',
+            [HEADER_STREAM_ID]: 'txt-1',
+            [HEADER_TURN_ID]: 'turn-1',
+            [`${D}id`]: 'txt-1',
+          },
+        ),
+      );
+
+      // finish — clears scope
+      decoder.decode(
+        withHeaders(
+          { action: 'message.create', name: 'finish', data: '' },
+          { [HEADER_STREAM]: 'false', [HEADER_TURN_ID]: 'turn-1', [`${D}finishReason`]: 'stop' },
+        ),
+      );
+
+      // New content on same turn — should re-synthesize start + start-step
+      const outputs = decoder.decode(
+        withHeaders(
+          { action: 'message.create', serial: 's2', name: 'text', data: '' },
+          {
+            [HEADER_STREAM]: 'true',
+            [HEADER_STATUS]: 'streaming',
+            [HEADER_STREAM_ID]: 'txt-2',
+            [HEADER_TURN_ID]: 'turn-1',
+            [`${D}id`]: 'txt-2',
+          },
+        ),
+      );
+      expect(eventTypesOf(outputs)).toContain('start');
+      expect(eventTypesOf(outputs)).toContain('start-step');
+    });
+
+    it('clears lifecycle scope after abort', () => {
+      const decoder = createDecoder();
+
+      // Stream content — synthesizes start + start-step
+      decoder.decode(
+        withHeaders(
+          { action: 'message.create', serial: 's1', name: 'text', data: '' },
+          {
+            [HEADER_STREAM]: 'true',
+            [HEADER_STATUS]: 'streaming',
+            [HEADER_STREAM_ID]: 'txt-1',
+            [HEADER_TURN_ID]: 'turn-1',
+            [`${D}id`]: 'txt-1',
+          },
+        ),
+      );
+
+      // abort — clears scope
+      decoder.decode(
+        withHeaders(
+          { action: 'message.create', name: 'abort', data: 'cancelled' },
+          { [HEADER_STREAM]: 'false', [HEADER_TURN_ID]: 'turn-1' },
+        ),
+      );
+
+      // New content on same turn — should re-synthesize start + start-step
+      const outputs = decoder.decode(
+        withHeaders(
+          { action: 'message.create', serial: 's2', name: 'text', data: '' },
+          {
+            [HEADER_STREAM]: 'true',
+            [HEADER_STATUS]: 'streaming',
+            [HEADER_STREAM_ID]: 'txt-2',
+            [HEADER_TURN_ID]: 'turn-1',
+            [`${D}id`]: 'txt-2',
+          },
+        ),
+      );
+      expect(eventTypesOf(outputs)).toContain('start');
+      expect(eventTypesOf(outputs)).toContain('start-step');
+    });
+
+    it('clears lifecycle scope after error', () => {
+      const decoder = createDecoder();
+
+      // Stream content — synthesizes start + start-step
+      decoder.decode(
+        withHeaders(
+          { action: 'message.create', serial: 's1', name: 'text', data: '' },
+          {
+            [HEADER_STREAM]: 'true',
+            [HEADER_STATUS]: 'streaming',
+            [HEADER_STREAM_ID]: 'txt-1',
+            [HEADER_TURN_ID]: 'turn-1',
+            [`${D}id`]: 'txt-1',
+          },
+        ),
+      );
+
+      // error — clears scope
+      decoder.decode(
+        withHeaders(
+          { action: 'message.create', name: 'error', data: 'something broke' },
+          { [HEADER_STREAM]: 'false', [HEADER_TURN_ID]: 'turn-1' },
+        ),
+      );
+
+      // New content on same turn — should re-synthesize start + start-step
+      const outputs = decoder.decode(
+        withHeaders(
+          { action: 'message.create', serial: 's2', name: 'text', data: '' },
+          {
+            [HEADER_STREAM]: 'true',
+            [HEADER_STATUS]: 'streaming',
+            [HEADER_STREAM_ID]: 'txt-2',
+            [HEADER_TURN_ID]: 'turn-1',
+            [`${D}id`]: 'txt-2',
+          },
+        ),
+      );
+      expect(eventTypesOf(outputs)).toContain('start');
+      expect(eventTypesOf(outputs)).toContain('start-step');
+    });
   });
 
   // -- first-contact update -------------------------------------------------