fix(task): add { once: true } to abort event listeners to prevent memory leaks

- Add { once: true } to the controller cleanup listener (L4179)
- Add { once: true } to the abortPromise reject listener (L4194)
- Prevents duplicate listener accumulation if signal fires multiple times

test(task): add abort signal lifecycle tests

- Test that abort listener clears controller reference
- Test that { once: true } prevents duplicate calls on repeated abort
- Test immediate rejection when signal is already aborted

Author: easonliang28

src/api/__tests__/task-abort-signal-passing.spec.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest"
+
+import type { ApiHandlerCreateMessageMetadata } from "../index"
+
+describe("abort signal passing", () => {
+	it("should pass the same AbortController signal instance to metadata.abortSignal", () => {
+		// Arrange: create an AbortController
+		const controller = new AbortController()
+
+		// Act: simulate what Task.ts does - construct metadata with abortSignal
+		const metadata: ApiHandlerCreateMessageMetadata = {
+			taskId: "test-task-id",
+			abortSignal: controller.signal,
+		}
+
+		// Assert: signal identity (toBe, not just toBeInstanceOf)
+		expect(metadata.abortSignal).toBe(controller.signal)
+	})
+
+	it("should create a fresh AbortController for each request", () => {
+		// Arrange: simulate two sequential requests
+		const controller1 = new AbortController()
+		const metadata1: ApiHandlerCreateMessageMetadata = {
+			taskId: "task-1",
+			abortSignal: controller1.signal,
+		}
+
+		const controller2 = new AbortController()
+		const metadata2: ApiHandlerCreateMessageMetadata = {
+			taskId: "task-2",
+			abortSignal: controller2.signal,
+		}
+
+		// Assert: different instances
+		expect(metadata1.abortSignal).not.toBe(metadata2.abortSignal)
+		expect(controller1.signal).not.toBe(controller2.signal)
+	})
+
+	it("should have abortSignal as undefined when not provided", () => {
+		const metadata: ApiHandlerCreateMessageMetadata = {
+			taskId: "test-task-id",
+		}
+
+		expect(metadata.abortSignal).toBeUndefined()
+	})
+
+	it("should preserve abortSignal state (aborted vs non-aborted)", () => {
+		const controller1 = new AbortController()
+		const controller2 = new AbortController()
+		controller2.abort()
+
+		const metadata1: ApiHandlerCreateMessageMetadata = {
+			taskId: "task-1",
+			abortSignal: controller1.signal,
+		}
+
+		const metadata2: ApiHandlerCreateMessageMetadata = {
+			taskId: "task-2",
+			abortSignal: controller2.signal,
+		}
+
+		expect(metadata1.abortSignal?.aborted).toBe(false)
+		expect(metadata2.abortSignal?.aborted).toBe(true)
+	})
+})

src/core/__tests__/task-abort-signal-passing.spec.ts

@@ -35,4 +35,72 @@ describe("abort signal passing", () => {
 		expect(metadata1.abortSignal).not.toBe(metadata2.abortSignal)
 		expect(controller1.signal).not.toBe(controller2.signal)
 	})
+
+	it("should trigger abort listener and clear controller reference", async () => {
+		const controller = new AbortController()
+		let controllerRef: AbortController | undefined = controller
+
+		// Simulate Task.ts abort listener setup with { once: true }
+		controller.signal.addEventListener(
+			"abort",
+			() => {
+				controllerRef = undefined
+			},
+			{ once: true },
+		)
+
+		// Verify initial state
+		expect(controllerRef).toBe(controller)
+		expect(controller.signal.aborted).toBe(false)
+
+		// Trigger abort
+		controller.abort()
+
+		// Verify listener was called and cleared the reference
+		expect(controllerRef).toBeUndefined()
+		expect(controller.signal.aborted).toBe(true)
+	})
+
+	it("should only trigger once even if signal is aborted multiple times", async () => {
+		const controller = new AbortController()
+		let callCount = 0
+
+		controller.signal.addEventListener(
+			"abort",
+			() => {
+				callCount++
+			},
+			{ once: true },
+		)
+
+		// First abort
+		controller.abort()
+		expect(callCount).toBe(1)
+
+		// Second abort (AbortSignal allows this, though unusual)
+		controller.abort()
+		expect(callCount).toBe(1) // Should still be 1 because of { once: true }
+	})
+
+	it("should reject promise immediately if signal already aborted", async () => {
+		const controller = new AbortController()
+		controller.abort()
+
+		// Simulate the abortPromise logic from Task.ts
+		const abortPromise = new Promise<never>((_, reject) => {
+			if (controller.signal.aborted) {
+				reject(new Error("Request cancelled by user"))
+			} else {
+				controller.signal.addEventListener(
+					"abort",
+					() => {
+						reject(new Error("Request cancelled by user"))
+					},
+					{ once: true },
+				)
+			}
+		})
+
+		await expect(abortPromise).rejects.toThrow("Request cancelled by user")
+	})
 })

src/core/task/Task.ts

@@ -4176,10 +4176,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const iterator = stream[Symbol.asyncIterator]()
 
 		// Set up abort handling - when the signal is aborted, clean up the controller reference
-		abortSignal.addEventListener("abort", () => {
-			console.log(`[Task#${this.taskId}.${this.instanceId}] AbortSignal triggered for current request`)
-			this.currentRequestAbortController = undefined
-		})
+		abortSignal.addEventListener(
+			"abort",
+			() => {
+				console.log(`[Task#${this.taskId}.${this.instanceId}] AbortSignal triggered for current request`)
+				this.currentRequestAbortController = undefined
+			},
+			{ once: true },
+		)
 
 		try {
 			// Awaiting first chunk to see if it will throw an error.
@@ -4191,9 +4195,13 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				if (abortSignal.aborted) {
 					reject(new Error("Request cancelled by user"))
 				} else {
-					abortSignal.addEventListener("abort", () => {
-						reject(new Error("Request cancelled by user"))
-					})
+					abortSignal.addEventListener(
+						"abort",
+						() => {
+							reject(new Error("Request cancelled by user"))
+						},
+						{ once: true },
+					)
 				}
 			})