async function withOpenAITimeout<T>(

label: string,

timeoutMs: number,

run: (signal: AbortSignal) => Promise<T>,

run: (signal: AbortSignal, timeoutPromise: Promise<never>) => Promise<T>,

): Promise<T> {

const controller = new AbortController();

let timeout: ReturnType<typeof setTimeout> | undefined;

const timeoutPromise = new Promise<T>((_resolve, reject) => {

const timeoutPromise = new Promise<never>((_resolve, reject) => {

timeout = setTimeout(() => {

const error = new Error(`${label} exceeded timeout of ${timeoutMs}ms`);

reject(error);

controller.abort(error);

}, timeoutMs);

});

try {

return await Promise.race([run(controller.signal), timeoutPromise]);

return await Promise.race([run(controller.signal, timeoutPromise), timeoutPromise]);

} finally {

if (timeout) {

clearTimeout(timeout);

async function readBoundedResponseText(

response: Response,

maxChars = OPENAI_ERROR_BODY_MAX_CHARS,

timeoutPromise?: Promise<never>,

): Promise<string> {

if (!response.body) {

return "";

const decoder = new TextDecoder();

let text = "";

let truncated = false;

let canceled = false;

try {

while (text.length <= maxChars) {

const { done, value } = await reader.read();

const { done, value } = await readOpenAIErrorChunk(reader, timeoutPromise, () => {

canceled = true;

});

if (done) {

text += decoder.decode();

break;

} finally {

if (truncated) {

await reader.cancel().catch(() => undefined);

} else {

} else if (!canceled) {

reader.releaseLock();

}

}

return truncated ? `${text}\n[truncated]` : text;

}

function cancelOpenAIErrorReaderSoon(reader: ReadableStreamDefaultReader<Uint8Array>): void {

void Promise.resolve()

.then(() => reader.cancel())

.catch(() => undefined);

}

async function readOpenAIErrorChunk(

reader: ReadableStreamDefaultReader<Uint8Array>,

timeoutPromise: Promise<never> | undefined,

markCanceled: () => void,

): Promise<ReadableStreamReadResult<Uint8Array>> {

const readPromise = reader.read();

if (!timeoutPromise) {

return await readPromise;

}

let waitingForRead = true;

const timeoutReadPromise = timeoutPromise.catch((error: unknown) => {

if (waitingForRead) {

markCanceled();

cancelOpenAIErrorReaderSoon(reader);

}

throw error instanceof Error ? error : new Error("OpenAI error response body read timed out");

});

try {

return await Promise.race([readPromise, timeoutReadPromise]);

} finally {

waitingForRead = false;

}

}

type OpenAIJsonReadOptions = {

signal?: AbortSignal;

timeoutPromise?: Promise<never>;

};

async function readBoundedOpenAIJson(

response: Response,

maxBytes = OPENAI_RESPONSE_BODY_MAX_BYTES,

options: OpenAIJsonReadOptions = {},

): Promise<OpenAIResponse> {

const text = await readBoundedBodyText(response, "OpenAI classification", maxBytes, {

createTooLargeError: (message) =>

Object.assign(new Error(message), {

code: "ETOOBIG",

}),

signal: options.signal,

timeoutPromise: options.timeoutPromise,

});

return JSON.parse(text) as OpenAIResponse;

}

const payload = await withOpenAITimeout(

"OpenAI issue label classification request",

timeoutMs,

async (signal) => {

async (signal, timeoutPromise) => {

const response = await fetchImpl("https://api.openai.com/v1/responses", {

method: "POST",

headers: {

});

if (!response.ok) {

const text = await readBoundedResponseText(response);

const text = await readBoundedResponseText(response, undefined, timeoutPromise);

throw new Error(`OpenAI request failed (${response.status}): ${text}`);

}

return await readBoundedOpenAIJson(response);

return await readBoundedOpenAIJson(response, undefined, { signal, timeoutPromise });

},

);

const rawText = extractResponseText(payload);