Skip to content

Commit 2296b74

Browse files
committed
fix(api): address CodeRabbit review on openai-native and openai-compatible abort handling
- openai-native.ts: bridge external abort signal to a request-local controller in executeRequest and makeResponsesApiRequest; detach the { once: true } listener in finally so a late abort from an earlier request cannot cancel a later request's controller (listener closures no longer read the mutable this.abortController field) - openai-native.spec.ts: regression test - first stream completes normally, second stream runs with a different external signal, aborting the FIRST signal must not cancel the second stream - openai-compatible.spec.ts: timeout tests now assert the generated signal actually fires on its own ~50ms timeout (a never-expiring signal can no longer pass), the merged-signal timeout component fires independently of the caller signal, and caller signals pass through by identity when timeoutMs is 0 or negative
1 parent d53b955 commit 2296b74

3 files changed

Lines changed: 188 additions & 21 deletions

File tree

‎src/api/providers/__tests__/openai-compatible.spec.ts‎

Lines changed: 58 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -78,30 +78,66 @@ describe("OpenAICompatibleHandler", () => {
7878
expect(mockGenerateText.mock.calls[0][0].abortSignal).toBe(controller.signal)
7979
})
8080

81-
it("should pass timeoutMs through to generateText as a timeout abort signal", async () => {
81+
it("should pass timeoutMs through to generateText as a working timeout abort signal", async () => {
8282
mockGenerateText.mockResolvedValue({ text: "response" })
8383

84-
await handler.completePrompt("test prompt", { timeoutMs: 5000 })
84+
await handler.completePrompt("test prompt", { timeoutMs: 50 })
8585

8686
const { abortSignal } = mockGenerateText.mock.calls[0][0]
8787
expect(abortSignal).toBeInstanceOf(AbortSignal)
8888
expect(abortSignal.aborted).toBe(false)
89+
90+
// A never-expiring signal (or a pre-aborted one) would fail this check:
91+
// the signal must fire on its own ~50ms timeout without any external abort.
92+
const fired = await Promise.race([
93+
new Promise<boolean>((resolve) => {
94+
abortSignal.addEventListener("abort", () => resolve(true), { once: true })
95+
}),
96+
new Promise<boolean>((resolve) => {
97+
setTimeout(() => resolve(false), 1000)
98+
}),
99+
])
100+
expect(fired).toBe(true)
101+
expect(abortSignal.aborted).toBe(true)
89102
})
90103

91104
it("should merge signal and timeout when both are provided", async () => {
92105
mockGenerateText.mockResolvedValue({ text: "response" })
93106

94107
const controller = new AbortController()
95-
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: 10000 })
108+
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: 50 })
96109

97110
const mergedSignal = mockGenerateText.mock.calls[0][0].abortSignal as AbortSignal
98111
expect(mergedSignal).toBeInstanceOf(AbortSignal)
112+
expect(mergedSignal.aborted).toBe(false)
99113

100114
// Aborting the external signal must abort the merged signal synchronously
101115
controller.abort()
102116
expect(mergedSignal.aborted).toBe(true)
103117
})
104118

119+
it("should let the timeout component of a merged signal fire without the caller signal", async () => {
120+
mockGenerateText.mockResolvedValue({ text: "response" })
121+
122+
await handler.completePrompt("test prompt", { abortSignal: new AbortController().signal, timeoutMs: 50 })
123+
124+
const mergedSignal = mockGenerateText.mock.calls[0][0].abortSignal as AbortSignal
125+
expect(mergedSignal).toBeInstanceOf(AbortSignal)
126+
expect(mergedSignal.aborted).toBe(false)
127+
128+
// With the caller signal left untouched, only the timeout component can fire
129+
const fired = await Promise.race([
130+
new Promise<boolean>((resolve) => {
131+
mergedSignal.addEventListener("abort", () => resolve(true), { once: true })
132+
}),
133+
new Promise<boolean>((resolve) => {
134+
setTimeout(() => resolve(false), 1000)
135+
}),
136+
])
137+
expect(fired).toBe(true)
138+
expect(mergedSignal.aborted).toBe(true)
139+
})
140+
105141
it("should work without options (backward compatible)", async () => {
106142
mockGenerateText.mockResolvedValue({ text: "response" })
107143

@@ -121,6 +157,25 @@ describe("OpenAICompatibleHandler", () => {
121157
expect(mockGenerateText.mock.calls[1][0].abortSignal).toBeUndefined()
122158
})
123159

160+
it("should pass the caller signal unchanged when timeoutMs is 0", async () => {
161+
mockGenerateText.mockResolvedValue({ text: "response" })
162+
163+
const controller = new AbortController()
164+
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: 0 })
165+
166+
// A disabled timeout must not drop the caller's cancellation signal
167+
expect(mockGenerateText.mock.calls[0][0].abortSignal).toBe(controller.signal)
168+
})
169+
170+
it("should pass the caller signal unchanged when timeoutMs is negative", async () => {
171+
mockGenerateText.mockResolvedValue({ text: "response" })
172+
173+
const controller = new AbortController()
174+
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: -1 })
175+
176+
expect(mockGenerateText.mock.calls[0][0].abortSignal).toBe(controller.signal)
177+
})
178+
124179
it("should reject with AbortError when abortSignal is already aborted before request", async () => {
125180
mockGenerateText.mockImplementation((options: { abortSignal?: AbortSignal }) => {
126181
if (options.abortSignal?.aborted) {

‎src/api/providers/__tests__/openai-native.spec.ts‎

Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -435,6 +435,88 @@ describe("OpenAiNativeHandler", () => {
435435

436436
await expect(collected).rejects.toMatchObject({ name: "AbortError" })
437437
})
438+
439+
it("should not let a late abort from an earlier request cancel a later request", async () => {
440+
// Regression: the external-signal bridge must detach on request completion.
441+
// With a lingering listener (or one reading the mutable this.abortController
442+
// field), aborting the FIRST request's signal after completion would cancel
443+
// the SECOND request's controller.
444+
mockResponsesCreate.mockRejectedValue(new Error("SDK not available"))
445+
446+
type OpenStream = {
447+
controller?: ReadableStreamDefaultController<Uint8Array>
448+
fetchSignal: AbortSignal
449+
}
450+
const openStreams: OpenStream[] = []
451+
const mockFetch = vitest.fn().mockImplementation((_url: string, options?: RequestInit) => {
452+
const entry: OpenStream = { fetchSignal: options?.signal as AbortSignal }
453+
const body = new ReadableStream<Uint8Array>({
454+
start: (controller) => {
455+
entry.controller = controller
456+
},
457+
})
458+
openStreams.push(entry)
459+
return Promise.resolve({
460+
ok: true,
461+
body,
462+
})
463+
})
464+
global.fetch = mockFetch as typeof fetch
465+
466+
const requireController = (index: number): ReadableStreamDefaultController<Uint8Array> => {
467+
const entry = openStreams[index]
468+
if (!entry?.controller) {
469+
throw new Error("expected fallback fetch to have started")
470+
}
471+
return entry.controller
472+
}
473+
474+
const firstController = new AbortController()
475+
const secondController = new AbortController()
476+
477+
// First request: completes normally.
478+
const firstStream = handler.createMessage(
479+
systemPrompt,
480+
messages,
481+
makeCreateMessageMetadata({ abortSignal: firstController.signal }),
482+
)
483+
const firstCollected = collectStream(firstStream)
484+
await new Promise((resolve) => setTimeout(resolve, 10))
485+
requireController(0).enqueue(
486+
new TextEncoder().encode('data: {"type":"response.text.delta","delta":"one"}\n\n'),
487+
)
488+
requireController(0).enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
489+
requireController(0).close()
490+
491+
const firstChunks = await firstCollected
492+
expect(firstChunks.some((chunk) => chunk.type === "text" && chunk.text === "one")).toBe(true)
493+
494+
// Second request with a different external signal, left in-flight.
495+
const secondStream = handler.createMessage(
496+
systemPrompt,
497+
messages,
498+
makeCreateMessageMetadata({ abortSignal: secondController.signal }),
499+
)
500+
const secondCollected = collectStream(secondStream)
501+
await new Promise((resolve) => setTimeout(resolve, 10))
502+
expect(openStreams).toHaveLength(2)
503+
504+
// Aborting the FIRST request's signal must not leak into the second request.
505+
firstController.abort()
506+
507+
// The second request's internal fetch signal must remain active...
508+
expect(openStreams[1].fetchSignal.aborted).toBe(false)
509+
510+
// ...and the second stream must still complete normally.
511+
requireController(1).enqueue(
512+
new TextEncoder().encode('data: {"type":"response.text.delta","delta":"two"}\n\n'),
513+
)
514+
requireController(1).enqueue(new TextEncoder().encode("data: [DONE]\n\n"))
515+
requireController(1).close()
516+
517+
const secondChunks = await secondCollected
518+
expect(secondChunks.some((chunk) => chunk.type === "text" && chunk.text === "two")).toBe(true)
519+
})
438520
})
439521

440522
describe("completePrompt", () => {

‎src/api/providers/openai-native.ts‎

Lines changed: 48 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -411,18 +411,25 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
411411
systemPrompt?: string,
412412
messages?: Anthropic.Messages.MessageParam[],
413413
): ApiStream {
414-
// Create AbortController for cancellation
415-
this.abortController = new AbortController()
416-
417-
// Bridge external abort signal to our internal controller using the Bedrock pattern:
414+
// Create a request-local AbortController for cancellation. It is exposed via
415+
// this.abortController so the stop-button path can observe it, but all bridging
416+
// below captures the local reference so a late abort from an earlier request can
417+
// never reach a later request's controller.
418+
const requestController = new AbortController()
419+
this.abortController = requestController
420+
421+
// Bridge external abort signal to the request controller using the Bedrock pattern:
418422
// - pre-aborted guard: check if already aborted before adding listener
419-
// - { once: true }: remove listener after first abort to avoid leaks
423+
// - { once: true }: removes the listener after the first abort to avoid leaks
424+
// The listener is removed in the finally block when the request completes.
425+
let abortListener: (() => void) | undefined
420426
const externalAbortSignal = metadata?.abortSignal
421427
if (externalAbortSignal) {
422428
if (externalAbortSignal.aborted) {
423-
this.abortController.abort()
429+
requestController.abort()
424430
} else {
425-
externalAbortSignal.addEventListener("abort", () => this.abortController?.abort(), { once: true })
431+
abortListener = () => requestController.abort()
432+
externalAbortSignal.addEventListener("abort", abortListener, { once: true })
426433
}
427434
}
428435

@@ -438,7 +445,7 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
438445
try {
439446
// Use the official SDK with per-request headers
440447
const stream = (await (this.client as any).responses.create(requestBody, {
441-
signal: this.abortController.signal,
448+
signal: requestController.signal,
442449
headers: requestHeaders,
443450
})) as AsyncIterable<any>
444451

@@ -450,7 +457,7 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
450457

451458
for await (const event of stream) {
452459
// Check if request was aborted
453-
if (this.abortController.signal.aborted) {
460+
if (requestController.signal.aborted) {
454461
break
455462
}
456463

@@ -462,7 +469,16 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
462469
// For errors, fallback to manual SSE via fetch
463470
yield* this.makeResponsesApiRequest(requestBody, model, metadata, systemPrompt, messages)
464471
} finally {
465-
this.abortController = undefined
472+
// Detach the bridging listener so a late abort from this request cannot
473+
// cancel a later request's controller.
474+
if (abortListener) {
475+
externalAbortSignal?.removeEventListener("abort", abortListener)
476+
}
477+
// Only clear the field if this request still owns it (the fallback path may
478+
// have installed its own controller, which it clears itself).
479+
if (this.abortController === requestController) {
480+
this.abortController = undefined
481+
}
466482
}
467483
}
468484

@@ -573,18 +589,25 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
573589
const baseUrl = this.options.openAiNativeBaseUrl || "https://api.openai.com"
574590
const url = `${baseUrl}/v1/responses`
575591

576-
// Create AbortController for cancellation
577-
this.abortController = new AbortController()
592+
// Create a request-local AbortController for cancellation. It is exposed via
593+
// this.abortController so the stop-button path can observe it, but the bridging
594+
// listener captures the local reference so a late abort from an earlier request
595+
// can never reach a later request's controller.
596+
const requestController = new AbortController()
597+
this.abortController = requestController
578598

579-
// Bridge external abort signal to our internal controller using the Bedrock pattern:
599+
// Bridge external abort signal to the request controller using the Bedrock pattern:
580600
// - pre-aborted guard: check if already aborted before adding listener
581-
// - { once: true }: remove listener after first abort to avoid leaks
601+
// - { once: true }: removes the listener after the first abort to avoid leaks
602+
// The listener is removed in the finally block when the request completes.
603+
let abortListener: (() => void) | undefined
582604
const externalAbortSignal = metadata?.abortSignal
583605
if (externalAbortSignal) {
584606
if (externalAbortSignal.aborted) {
585-
this.abortController.abort()
607+
requestController.abort()
586608
} else {
587-
externalAbortSignal.addEventListener("abort", () => this.abortController?.abort(), { once: true })
609+
abortListener = () => requestController.abort()
610+
externalAbortSignal.addEventListener("abort", abortListener, { once: true })
588611
}
589612
}
590613

@@ -603,7 +626,7 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
603626
"User-Agent": userAgent,
604627
},
605628
body: JSON.stringify(requestBody),
606-
signal: this.abortController.signal,
629+
signal: requestController.signal,
607630
})
608631

609632
if (!response.ok) {
@@ -690,7 +713,14 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
690713
// Handle non-Error objects
691714
throw new Error(`Unexpected error connecting to Responses API`)
692715
} finally {
693-
this.abortController = undefined
716+
// Detach the bridging listener so a late abort from this request cannot
717+
// cancel a later request's controller.
718+
if (abortListener) {
719+
externalAbortSignal?.removeEventListener("abort", abortListener)
720+
}
721+
if (this.abortController === requestController) {
722+
this.abortController = undefined
723+
}
694724
}
695725
}
696726

0 commit comments

Comments
 (0)