Skip to content

Context7 Platform -- Up-to-date docs for AI agents

fix(sdk): honor cancellation while awaiting auth tokens (#3264)

Mohit Nirmal88618087fca5
diff --git a/.changeset/quiet-tokens-wait.md b/.changeset/quiet-tokens-wait.md
new file mode 100644
index 00000000..c02e8d37
--- /dev/null
+++ b/.changeset/quiet-tokens-wait.md
@@ -0,0 +1,5 @@
+---
+"@upstash/context7-sdk": patch
+---
+
+Honor request timeouts and cancellation while waiting for an asynchronous authentication token provider.
diff --git a/packages/sdk/src/http/abort.ts b/packages/sdk/src/http/abort.ts
index 096ce042..aabe4dd4 100644
--- a/packages/sdk/src/http/abort.ts
+++ b/packages/sdk/src/http/abort.ts
@@ -78,6 +78,28 @@ export function isContext7AbortError(error: unknown): boolean {
);
}
+/** Stop waiting on a value when cancelled, without cancelling its underlying work. */
+export async function awaitWithSignal<T>(
+ value: T | PromiseLike<T>,
+ signal?: AbortSignal
+): Promise<T> {
+ if (!signal) return value;
+
+ let onAbort!: () => void;
+ const aborted = new Promise<never>((_resolve, reject) => {
+ onAbort = () => reject(signal.reason);
+ if (signal.aborted) onAbort();
+ else signal.addEventListener("abort", onAbort, { once: true });
+ });
+
+ try {
+ // Keep a rejection handler on the provider even if cancellation wins the race.
+ return await Promise.race([value, aborted]);
+ } finally {
+ signal.removeEventListener("abort", onAbort);
+ }
+}
+
export async function wait(milliseconds: number, signal?: AbortSignal): Promise<void> {
if (milliseconds <= 0) return;
diff --git a/packages/sdk/src/http/index.test.ts b/packages/sdk/src/http/index.test.ts
index 8869226d..1521100d 100644
--- a/packages/sdk/src/http/index.test.ts
+++ b/packages/sdk/src/http/index.test.ts
@@ -124,6 +124,107 @@ describe("HttpClient error handling", () => {
expect(fetchMock).toHaveBeenCalledTimes(2);
});
+ test("times out while an auth token provider is still pending", async () => {
+ vi.useFakeTimers();
+ const authToken = vi.fn(() => new Promise<string>(() => {}));
+ const fetchMock = vi.fn();
+ const client = new HttpClient({
+ baseUrl: "https://example.com/api",
+ authToken,
+ fetch: fetchMock,
+ timeout: 25,
+ });
+ const onError = vi.fn();
+ const request = client.request({ method: "GET" }).catch(onError);
+
+ await vi.advanceTimersByTimeAsync(25);
+
+ expect(onError).toHaveBeenCalledWith(
+ expect.objectContaining({ code: "request_timeout", retryable: true })
+ );
+ await request;
+ expect(authToken).toHaveBeenCalledOnce();
+ expect(fetchMock).not.toHaveBeenCalled();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ test.each(["resolve", "reject"] as const)(
+ "cancels a pending token wait and handles a late provider %s",
+ async (settlement) => {
+ vi.useFakeTimers();
+ const controller = new AbortController();
+ let resolveToken!: (token: string) => void;
+ let rejectToken!: (error: Error) => void;
+ const authToken = vi.fn(
+ () =>
+ new Promise<string>((resolve, reject) => {
+ resolveToken = resolve;
+ rejectToken = reject;
+ })
+ );
+ const fetchMock = vi.fn();
+ const client = new HttpClient({
+ baseUrl: "https://example.com/api",
+ authToken,
+ fetch: fetchMock,
+ timeout: false,
+ });
+ const onError = vi.fn();
+ const request = client.request({ method: "GET", signal: controller.signal }).catch(onError);
+ const reason = new Error("User cancelled");
+ controller.abort(reason);
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(onError).toHaveBeenCalledWith(
+ expect.objectContaining({ code: "request_aborted", retryable: false, cause: reason })
+ );
+ await request;
+
+ if (settlement === "resolve") resolveToken("late-token");
+ else rejectToken(new Error("Late provider failure"));
+ await vi.advanceTimersByTimeAsync(0);
+
+ expect(onError).toHaveBeenCalledOnce();
+ expect(authToken).toHaveBeenCalledOnce();
+ expect(fetchMock).not.toHaveBeenCalled();
+ }
+ );
+
+ test("handles cancellation triggered synchronously by the token provider", async () => {
+ const controller = new AbortController();
+ const fetchMock = vi.fn();
+ const client = new HttpClient({
+ baseUrl: "https://example.com/api",
+ authToken: () => {
+ controller.abort();
+ return Promise.reject(new Error("Provider failed after cancellation"));
+ },
+ fetch: fetchMock,
+ });
+
+ await expect(client.request({ signal: controller.signal })).rejects.toMatchObject({
+ code: "request_aborted",
+ retryable: false,
+ });
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
+ test.each([true, false])("preserves token provider errors with timeout=%s", async (timeout) => {
+ const providerError = new Error("Token service unavailable");
+ const authToken = vi.fn().mockRejectedValue(providerError);
+ const fetchMock = vi.fn();
+ const client = new HttpClient({
+ baseUrl: "https://example.com/api",
+ authToken,
+ fetch: fetchMock,
+ timeout: timeout ? 25 : false,
+ });
+
+ await expect(client.request({ method: "GET" })).rejects.toBe(providerError);
+ expect(authToken).toHaveBeenCalledOnce();
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
test("uses the last failure when a retry later fails on the network", async () => {
const fetchMock = vi
.fn()
diff --git a/packages/sdk/src/http/index.ts b/packages/sdk/src/http/index.ts
index 98fa46b5..d59b077d 100644
--- a/packages/sdk/src/http/index.ts
+++ b/packages/sdk/src/http/index.ts
@@ -1,6 +1,7 @@
import { Context7Error, Context7UrlError } from "@error";
import {
abortError,
+ awaitWithSignal,
createAbortState,
isContext7AbortError,
resolveSignal,
@@ -120,9 +121,12 @@ export class HttpClient implements Requester {
const canRetry = method === "GET";
for (let attempt = 0; attempt <= this.retry.retries; attempt++) {
+ if (abortState.signal?.aborted) {
+ throw abortError(abortState.signal.reason, abortState.timedOut());
+ }
const headers =
typeof this.authToken === "function"
- ? this.headersForToken(await this.authToken())
+ ? this.headersForToken(await awaitWithSignal(this.authToken(), abortState.signal))
: this.headersForToken(this.authToken);
if (abortState.signal?.aborted) {
throw abortError(abortState.signal.reason, abortState.timedOut());