Skip to content

Commit 5fb2574

Browse files
committed
feat(api): abort signal and timeout support for anthropic, anthropic-vertex, xai, minimax
- completePrompt: forward CompletePromptOptions abortSignal/timeoutMs into the SDK request for AnthropicHandler, AnthropicVertexHandler, XAIHandler, and MiniMaxHandler (request options built only when a signal/timeout is provided, preserving existing behavior) - createMessage: bridge metadata?.abortSignal into a per-request AbortController using the Bedrock pattern (pre-aborted guard + { once: true } listener) and pass the internal signal as the SDK request signal; existing client-level timeout mechanisms are untouched - xai: rethrow AbortError unmodified from createMessage/completePrompt so callers can detect error.name === 'AbortError' - tests: port reference completePrompt signal/timeout propagation tests and add per-provider createMessage bridging tests (pre-aborted signal rejects with AbortError; mid-flight external abort cancels the request)
1 parent 38d5ee0 commit 5fb2574

8 files changed

Lines changed: 716 additions & 50 deletions

File tree

‎src/api/providers/__tests__/anthropic-vertex.spec.ts‎

Lines changed: 152 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import { VERTEX_1M_CONTEXT_MODEL_IDS } from "@roo-code/types"
88

99
import { AnthropicVertexHandler } from "../anthropic-vertex"
1010
import { asyncStreamFrom, collectStream } from "../../../test-utils/stream"
11+
import { makeCreateMessageMetadata } from "../../../test-utils/api"
1112

1213
vitest.mock("../utils/timeout-config", () => ({
1314
getApiRequestTimeout: vitest.fn().mockReturnValue(300_000),
@@ -746,6 +747,69 @@ describe("VertexHandler", () => {
746747
expect(calledMessages).toHaveLength(2) // Only the two user messages
747748
expect(calledMessages.every((m: any) => m.role === "user")).toBe(true)
748749
})
750+
751+
it("should reject with AbortError when createMessage is called with an already-aborted signal", async () => {
752+
const abortedController = new AbortController()
753+
abortedController.abort()
754+
755+
const mockCreate = vitest
756+
.spyOn(handler["client"].messages, "create")
757+
.mockImplementation((_params: unknown, options?: { signal?: AbortSignal | null }) => {
758+
if (options?.signal?.aborted) {
759+
const error = new Error("The operation was aborted")
760+
error.name = "AbortError"
761+
throw error
762+
}
763+
return asyncStreamFrom([]) as never
764+
})
765+
766+
const stream = handler.createMessage(
767+
systemPrompt,
768+
[{ role: "user", content: "Hello" }],
769+
makeCreateMessageMetadata({ abortSignal: abortedController.signal }),
770+
)
771+
772+
await expect(stream.next()).rejects.toMatchObject({ name: "AbortError" })
773+
})
774+
775+
it("should abort the request when the external signal aborts mid-flight", async () => {
776+
const controller = new AbortController()
777+
778+
const mockCreate = vitest.spyOn(handler["client"].messages, "create").mockImplementation(
779+
(_params: unknown, options?: { signal?: AbortSignal | null }) =>
780+
new Promise<void>((_resolve, reject) => {
781+
const signal = options?.signal
782+
if (!signal) {
783+
return
784+
}
785+
if (signal.aborted) {
786+
const error = new Error("The operation was aborted")
787+
error.name = "AbortError"
788+
reject(error)
789+
return
790+
}
791+
signal.addEventListener(
792+
"abort",
793+
() => {
794+
const error = new Error("The operation was aborted")
795+
error.name = "AbortError"
796+
reject(error)
797+
},
798+
{ once: true },
799+
)
800+
}) as never,
801+
)
802+
803+
const stream = handler.createMessage(
804+
systemPrompt,
805+
[{ role: "user", content: "Hello" }],
806+
makeCreateMessageMetadata({ abortSignal: controller.signal }),
807+
)
808+
809+
const promise = stream.next()
810+
controller.abort()
811+
await expect(promise).rejects.toMatchObject({ name: "AbortError" })
812+
})
749813
})
750814

751815
describe("completePrompt", () => {
@@ -758,18 +822,22 @@ describe("VertexHandler", () => {
758822

759823
const result = await handler.completePrompt("Test prompt")
760824
expect(result).toBe("Test response")
761-
expect(handler["client"].messages.create).toHaveBeenCalledWith({
762-
model: "claude-3-5-sonnet-v2@20241022",
763-
max_tokens: 8192,
764-
temperature: 0,
765-
messages: [
766-
{
767-
role: "user",
768-
content: [{ type: "text", text: "Test prompt", cache_control: { type: "ephemeral" } }],
769-
},
770-
],
771-
stream: false,
772-
})
825+
expect(handler["client"].messages.create).toHaveBeenCalledWith(
826+
{
827+
model: "claude-3-5-sonnet-v2@20241022",
828+
max_tokens: 8192,
829+
temperature: 0,
830+
messages: [
831+
{
832+
role: "user",
833+
content: [{ type: "text", text: "Test prompt", cache_control: { type: "ephemeral" } }],
834+
},
835+
],
836+
stream: false,
837+
thinking: undefined,
838+
},
839+
undefined,
840+
)
773841
})
774842

775843
it("should handle API errors for Claude", async () => {
@@ -820,6 +888,78 @@ describe("VertexHandler", () => {
820888
expect(result).toBe("")
821889
})
822890

891+
it("should pass abort signal through to client", async () => {
892+
handler = new AnthropicVertexHandler({
893+
apiModelId: "claude-3-5-sonnet-v2@20241022",
894+
vertexProjectId: "test-project",
895+
vertexRegion: "us-central1",
896+
})
897+
898+
const controller = new AbortController()
899+
const mockCreate = vitest
900+
.spyOn(handler["client"].messages, "create")
901+
.mockResolvedValue({ content: [{ type: "text", text: "response" }] } as never)
902+
903+
await handler.completePrompt("test prompt", { abortSignal: controller.signal })
904+
905+
const [, requestOptions] = mockCreate.mock.calls[0]
906+
expect(mockCreate).toHaveBeenCalledWith(
907+
expect.objectContaining({ model: expect.any(String) }),
908+
expect.any(Object),
909+
)
910+
expect(requestOptions?.signal).toBe(controller.signal)
911+
})
912+
913+
it("should work without options (backward compatible)", async () => {
914+
handler = new AnthropicVertexHandler({
915+
apiModelId: "claude-3-5-sonnet-v2@20241022",
916+
vertexProjectId: "test-project",
917+
vertexRegion: "us-central1",
918+
})
919+
920+
const mockCreate = vitest
921+
.spyOn(handler["client"].messages, "create")
922+
.mockResolvedValue({ content: [{ type: "text", text: "response" }] } as never)
923+
924+
const result = await handler.completePrompt("test prompt")
925+
expect(result).toBe("response")
926+
expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({ model: expect.any(String) }), undefined)
927+
})
928+
929+
it("completePrompt should pass signal through to client", async () => {
930+
handler = new AnthropicVertexHandler({
931+
apiModelId: "claude-3-5-sonnet-v2@20241022",
932+
vertexProjectId: "test-project",
933+
vertexRegion: "us-central1",
934+
})
935+
936+
const controller = new AbortController()
937+
const mockCreate = vitest
938+
.spyOn(handler["client"].messages, "create")
939+
.mockResolvedValue({ content: [{ type: "text", text: "response" }] } as never)
940+
941+
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: 5000 })
942+
943+
const [, requestOptions] = mockCreate.mock.calls[0]
944+
expect(mockCreate).toHaveBeenCalledWith(
945+
expect.objectContaining({ model: expect.any(String) }),
946+
expect.objectContaining({ timeout: 5000 }),
947+
)
948+
expect(requestOptions?.signal).toBe(controller.signal)
949+
})
950+
951+
it("completePrompt should pass timeoutMs when provided", async () => {
952+
const mockCreate = vitest
953+
.spyOn(handler["client"].messages, "create")
954+
.mockResolvedValue({ content: [{ type: "text", text: "response" }] } as never)
955+
956+
await handler.completePrompt("test prompt", { timeoutMs: 3000 })
957+
expect(mockCreate).toHaveBeenCalledWith(
958+
expect.objectContaining({ model: expect.any(String) }),
959+
expect.objectContaining({ timeout: 3000 }),
960+
)
961+
})
962+
823963
it("should handle empty content array for Claude", async () => {
824964
handler = new AnthropicVertexHandler({
825965
apiModelId: "claude-3-5-sonnet-v2@20241022",

‎src/api/providers/__tests__/anthropic.spec.ts‎

Lines changed: 152 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
import { AnthropicHandler } from "../anthropic"
44
import { ApiHandlerOptions } from "../../../shared/api"
55
import { asyncStreamFrom, collectStream } from "../../../test-utils/stream"
6+
import { makeCreateMessageMetadata } from "../../../test-utils/api"
67
import { clearAllMocks } from "../../../test-utils/reset"
78

89
// Mock TelemetryService
@@ -476,20 +477,83 @@ describe("AnthropicHandler", () => {
476477
expect(requestBody?.model).toBe("claude-sonnet-5-bf")
477478
expect(requestBody?.thinking).toEqual({ type: "adaptive" })
478479
})
480+
481+
it("should reject with AbortError when createMessage is called with an already-aborted signal", async () => {
482+
const abortedController = new AbortController()
483+
abortedController.abort()
484+
485+
mockCreate.mockImplementation(async (_params: unknown, options?: { signal?: AbortSignal }) => {
486+
if (options?.signal?.aborted) {
487+
const error = new Error("The operation was aborted")
488+
error.name = "AbortError"
489+
throw error
490+
}
491+
return asyncStreamFrom([])
492+
})
493+
494+
const stream = handler.createMessage(
495+
systemPrompt,
496+
[{ role: "user", content: "Hello" }],
497+
makeCreateMessageMetadata({ abortSignal: abortedController.signal }),
498+
)
499+
500+
await expect(stream.next()).rejects.toMatchObject({ name: "AbortError" })
501+
})
502+
503+
it("should abort the request when the external signal aborts mid-flight", async () => {
504+
const controller = new AbortController()
505+
506+
mockCreate.mockImplementation((_params: unknown, options?: { signal?: AbortSignal }) => {
507+
return new Promise<void>((_resolve, reject) => {
508+
const signal = options?.signal
509+
if (!signal) {
510+
return
511+
}
512+
if (signal.aborted) {
513+
const error = new Error("The operation was aborted")
514+
error.name = "AbortError"
515+
reject(error)
516+
return
517+
}
518+
signal.addEventListener(
519+
"abort",
520+
() => {
521+
const error = new Error("The operation was aborted")
522+
error.name = "AbortError"
523+
reject(error)
524+
},
525+
{ once: true },
526+
)
527+
})
528+
})
529+
530+
const stream = handler.createMessage(
531+
systemPrompt,
532+
[{ role: "user", content: "Hello" }],
533+
makeCreateMessageMetadata({ abortSignal: controller.signal }),
534+
)
535+
536+
const promise = stream.next()
537+
controller.abort()
538+
await expect(promise).rejects.toMatchObject({ name: "AbortError" })
539+
})
479540
})
480541

481542
describe("completePrompt", () => {
482543
it("should complete prompt successfully", async () => {
483544
const result = await handler.completePrompt("Test prompt")
484545
expect(result).toBe("Test response")
485-
expect(mockCreate).toHaveBeenCalledWith({
486-
model: mockOptions.apiModelId,
487-
messages: [{ role: "user", content: "Test prompt" }],
488-
max_tokens: 8192,
489-
temperature: 0,
490-
thinking: undefined,
491-
stream: false,
492-
})
546+
expect(mockCreate).toHaveBeenCalledWith(
547+
{
548+
model: mockOptions.apiModelId,
549+
messages: [{ role: "user", content: "Test prompt" }],
550+
max_tokens: 8192,
551+
temperature: 0,
552+
thinking: undefined,
553+
stream: false,
554+
},
555+
undefined,
556+
)
493557
})
494558

495559
it("should handle API errors", async () => {
@@ -512,6 +576,86 @@ describe("AnthropicHandler", () => {
512576
const result = await handler.completePrompt("Test prompt")
513577
expect(result).toBe("")
514578
})
579+
580+
it("should pass abort signal through to client", async () => {
581+
const controller = new AbortController()
582+
mockCreate.mockResolvedValueOnce({ content: [{ type: "text", text: "response" }] })
583+
await handler.completePrompt("test prompt", { abortSignal: controller.signal })
584+
expect(mockCreate).toHaveBeenCalledWith(
585+
{
586+
model: mockOptions.apiModelId,
587+
messages: [{ role: "user", content: "test prompt" }],
588+
max_tokens: 8192,
589+
temperature: 0,
590+
thinking: undefined,
591+
stream: false,
592+
},
593+
{ signal: controller.signal },
594+
)
595+
})
596+
597+
it("should work without options (backward compatible)", async () => {
598+
mockCreate.mockResolvedValueOnce({ content: [{ type: "text", text: "response" }] })
599+
const result = await handler.completePrompt("test prompt")
600+
expect(result).toBe("response")
601+
expect(mockCreate).toHaveBeenCalledWith(
602+
{
603+
model: mockOptions.apiModelId,
604+
messages: [{ role: "user", content: "test prompt" }],
605+
max_tokens: 8192,
606+
temperature: 0,
607+
thinking: undefined,
608+
stream: false,
609+
},
610+
undefined,
611+
)
612+
})
613+
614+
it("should merge signal and timeout together", async () => {
615+
const controller = new AbortController()
616+
mockCreate.mockResolvedValueOnce({ content: [{ type: "text", text: "response" }] })
617+
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: 10000 })
618+
expect(mockCreate).toHaveBeenCalledWith(
619+
{
620+
model: mockOptions.apiModelId,
621+
messages: [{ role: "user", content: "test prompt" }],
622+
max_tokens: 8192,
623+
temperature: 0,
624+
thinking: undefined,
625+
stream: false,
626+
},
627+
expect.objectContaining({ signal: controller.signal, timeout: 10000 }),
628+
)
629+
})
630+
631+
it("should pass timeoutMs through to client alongside abortSignal", async () => {
632+
const controller = new AbortController()
633+
mockCreate.mockResolvedValueOnce({ content: [{ type: "text", text: "response" }] })
634+
await handler.completePrompt("test prompt", { abortSignal: controller.signal, timeoutMs: 5000 })
635+
expect(mockCreate).toHaveBeenCalledWith(
636+
expect.objectContaining({ model: mockOptions.apiModelId }),
637+
expect.objectContaining({ signal: controller.signal, timeout: 5000 }),
638+
)
639+
})
640+
641+
it("should pass the same signal instance", async () => {
642+
const controller = new AbortController()
643+
mockCreate.mockResolvedValueOnce({ content: [{ type: "text", text: "response" }] })
644+
await handler.completePrompt("test prompt", { abortSignal: controller.signal })
645+
expect(mockCreate).toHaveBeenCalledWith(
646+
expect.any(Object),
647+
expect.objectContaining({ signal: controller.signal }),
648+
)
649+
// Verify it's the exact same instance, not just equal
650+
const callOptions = mockCreate.mock.calls[0][1]
651+
expect(callOptions?.signal).toBe(controller.signal)
652+
})
653+
654+
it("should not include signal-related options when not provided", async () => {
655+
mockCreate.mockResolvedValueOnce({ content: [{ type: "text", text: "response" }] })
656+
await handler.completePrompt("test prompt")
657+
expect(mockCreate).toHaveBeenCalledWith(expect.any(Object), undefined)
658+
})
515659
})
516660

517661
describe("getModel", () => {

0 commit comments

Comments
 (0)