const abortReason = new Error("live anthropic stream abort");

let requestBody = "";

let requestBodyPromise: Promise<string> | undefined;

let responseClosed = false;

let resolveResponseClosed: (() => void) | undefined;

const responseClosedPromise = new Promise<void>((resolve) => {

resolveResponseClosed = resolve;

let connectionClosed = false;

let resolveConnectionClosed: (() => void) | undefined;

const connectionClosedPromise = new Promise<void>((resolve) => {

resolveConnectionClosed = resolve;

});

const server = http.createServer((request, response) => {

const markConnectionClosed = () => {

connectionClosed = true;

resolveConnectionClosed?.();

};

request.on("aborted", markConnectionClosed);

request.on("close", markConnectionClosed);

response.on("close", () => {

responseClosed = true;

resolveResponseClosed?.();

markConnectionClosed();

});

requestBodyPromise = readRequestBody(request).then((body) => {

requestBody = body;

if (result === timedOut) {

throw new Error("Anthropic live SSE stream did not abort within 1000ms");

}

await Promise.race([responseClosedPromise, delay(1_000, undefined)]);

const observedConnectionClose = await Promise.race([

connectionClosedPromise.then(() => true),

delay(2_000, false),

]);

expect(result.stopReason).toBe("aborted");

expect(result.errorMessage).toBe("live anthropic stream abort");

expect(responseClosed).toBe(true);

expect(observedConnectionClose || connectionClosed).toBe(true);

const capturedRequestBody = requestBodyPromise

? await Promise.race([requestBodyPromise, delay(500, requestBody)])

: requestBody;