@ottocode/sdk 0.1.281 → 0.1.283

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.281",
+	"version": "0.1.283",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/providers/src/openai-oauth-client.ts

@@ -15,8 +15,10 @@ const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
 const TOKEN_REFRESH_MAX_RETRIES = 2;
 const TOKEN_REFRESH_RETRY_DELAY_MS = 1000;
 const CODEX_INSTALLATION_ID = crypto.randomUUID();
-const CODEX_REQUEST_TIMEOUT_MS = 120_000;
-const CODEX_STREAM_IDLE_TIMEOUT_MS = 120_000;
+const CODEX_REQUEST_TIMEOUT_MS = 20_000;
+const CODEX_STREAM_IDLE_TIMEOUT_MS = 20_000;
+const CODEX_REQUEST_MAX_RETRIES = 3;
+const CODEX_REQUEST_RETRY_DELAY_MS = 500;
 
 type OpenAIOAuthSessionState = {
 	responseId?: string;
@@ -110,6 +112,20 @@ function getCodexStreamIdleTimeoutMs() {
 	);
 }
 
+function getCodexRequestMaxRetries() {
+	return parsePositiveIntegerEnv(
+		'OTTO_OPENAI_OAUTH_REQUEST_MAX_RETRIES',
+		CODEX_REQUEST_MAX_RETRIES,
+	);
+}
+
+function getCodexRequestRetryDelayMs() {
+	return parsePositiveIntegerEnv(
+		'OTTO_OPENAI_OAUTH_REQUEST_RETRY_DELAY_MS',
+		CODEX_REQUEST_RETRY_DELAY_MS,
+	);
+}
+
 export function clearOpenAIOAuthSessionState(sessionId?: string) {
 	if (sessionId) {
 		openAIOAuthSessionState.delete(sessionId);
@@ -452,6 +468,108 @@ function trackResponsesStream(
 	});
 }
 
+async function waitForCodexStreamStart(
+	response: Response,
+	args: {
+		sessionId?: string;
+		model?: string;
+		parentSignal?: AbortSignal | null;
+	},
+): Promise<Response> {
+	if (!response.ok || !response.body) {
+		return response;
+	}
+
+	const reader = response.body.getReader();
+	const idleTimeoutMs = getCodexStreamIdleTimeoutMs();
+	let timeout: Timer | undefined;
+	let removeAbortListener: (() => void) | undefined;
+	const cleanup = () => {
+		if (timeout) clearTimeout(timeout);
+		timeout = undefined;
+		removeAbortListener?.();
+		removeAbortListener = undefined;
+	};
+
+	try {
+		const first = await Promise.race([
+			reader.read(),
+			new Promise<never>((_resolve, reject) => {
+				timeout = setTimeout(() => {
+					reject(
+						new Error(
+							`OpenAI OAuth Codex stream idle timeout before first chunk after ${idleTimeoutMs}ms`,
+						),
+					);
+				}, idleTimeoutMs);
+
+				if (args.parentSignal) {
+					const onAbort = () => {
+						reject(args.parentSignal?.reason ?? new Error('Request aborted'));
+					};
+					if (args.parentSignal.aborted) {
+						onAbort();
+					} else {
+						args.parentSignal.addEventListener('abort', onAbort, {
+							once: true,
+						});
+						removeAbortListener = () =>
+							args.parentSignal?.removeEventListener('abort', onAbort);
+					}
+				}
+			}),
+		]);
+		cleanup();
+
+		if (first.done) {
+			return new Response(null, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers,
+			});
+		}
+
+		const body = new ReadableStream<Uint8Array>({
+			start(controller) {
+				controller.enqueue(first.value);
+			},
+			async pull(controller) {
+				try {
+					const next = await reader.read();
+					if (next.done) {
+						controller.close();
+						return;
+					}
+					controller.enqueue(next.value);
+				} catch (error) {
+					controller.error(error);
+				}
+			},
+			async cancel(reason) {
+				await reader.cancel(reason);
+			},
+		});
+
+		return new Response(body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers,
+		});
+	} catch (error) {
+		cleanup();
+		loggerWarn('[openai-oauth] response stream did not start before timeout', {
+			sessionId: args.sessionId,
+			model: args.model,
+			timeoutMs: idleTimeoutMs,
+			error: summarizeError(error),
+		});
+		try {
+			await reader.cancel(error);
+		} catch {}
+		throw error;
+	}
+}
+
 async function fetchWithCodexRequestTimeout(
 	url: string,
 	init: RequestInit,
@@ -470,6 +588,55 @@ async function fetchWithCodexRequestTimeout(
 		});
 	}
 
+	const maxRetries = getCodexRequestMaxRetries();
+	let lastError: unknown;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		const attemptStartedAt = Date.now();
+		try {
+			const response = await fetchCodexRequestAttemptWithTimeout(url, init, {
+				...args,
+				requestStartedAt: attemptStartedAt,
+			});
+			return await waitForCodexStreamStart(response, {
+				sessionId: args.sessionId,
+				model: args.model,
+				parentSignal: init.signal,
+			});
+		} catch (error) {
+			lastError = error;
+			if (init.signal?.aborted || attempt >= maxRetries) {
+				throw error;
+			}
+
+			const retryDelayMs = getCodexRequestRetryDelayMs() * (attempt + 1);
+			loggerWarn('[openai-oauth] request attempt failed before stream start', {
+				sessionId: args.sessionId,
+				model: args.model,
+				attempt: attempt + 1,
+				maxRetries,
+				nextAttempt: attempt + 2,
+				requestTimeoutMs: getCodexRequestTimeoutMs(),
+				streamIdleTimeoutMs: getCodexStreamIdleTimeoutMs(),
+				durationMs: Date.now() - attemptStartedAt,
+				retryDelayMs,
+				error: summarizeError(error),
+			});
+			await sleep(retryDelayMs);
+		}
+	}
+
+	throw lastError;
+}
+
+async function fetchCodexRequestAttemptWithTimeout(
+	url: string,
+	init: RequestInit,
+	args: {
+		sessionId?: string;
+		model?: string;
+		requestStartedAt: number;
+	},
+) {
 	const timeoutMs = getCodexRequestTimeoutMs();
 	const controller = new AbortController();
 	const timeout = setTimeout(() => {