resolveTimerTimeoutMs,

clampTimerTimeoutMs,

} from "@openclaw/normalization-core/number-coercion";

import { createSseByteGuard } from "../../agents/streaming-byte-guard.js";

import { stripSystemPromptCacheBoundary } from "../../agents/system-prompt-cache-boundary.js";

import { getEnvApiKey } from "../env-api-keys.js";

import { clampThinkingLevel } from "../model-utils.js";

/^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{2} \d{2}:\d{2}:\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [ \d]\d \d{2}:\d{2}:\d{2} \d{4})$/;

const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "opencode"]);

const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;

const OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES = 16 * 1024;

const OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES = 16 * 1024 * 1024;

const CODEX_RESPONSE_STATUSES = new Set<CodexResponseStatus>([

"completed",

break;

}

const errorText = await response.text();

const errorText = await readChatGptResponsesErrorTextLimited(response);

if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {

let delayMs = BASE_DELAY_MS * 2 ** attempt;

}

const reader = response.body.getReader();

// Cap the streaming 200 success-body read at 16 MiB, mirroring the

// non-streaming `readProviderJsonResponse` cap so a hostile or

// malfunctioning ChatGPT Responses endpoint cannot exhaust memory by

// streaming an unbounded SSE body.

const guard = createSseByteGuard(reader, {

maxBytes: OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES,

onOverflow: ({ size, maxBytes }) =>

new Error(

`OpenAI ChatGPT Responses success body exceeded ${maxBytes} bytes (received ${size})`,

),

});

const decoder = new TextDecoder();

let buffer = "";

try {

while (true) {

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

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

if (done) {

break;

}

}

} finally {

try {

await reader.cancel();

await guard.cancel();

} catch {}

try {

reader.releaseLock();

} catch {}

}

}

// Test-only re-export of the bounded SSE parser. Mirrors

// `parseAnthropicSseBodyForTest` / `iterateSseMessagesForTest` patterns.

export const parseSSEForTest = parseSSE;

// ============================================================================

// WebSocket Parsing

// ============================================================================

// Error Handling

// ============================================================================

async function readChatGptResponsesErrorTextLimited(response: Response): Promise<string> {

const reader = response.body?.getReader();

if (!reader) {

return "";

}

const decoder = new TextDecoder();

let total = 0;

let text = "";

let reachedLimit = false;

try {

while (true) {

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

if (done) {

break;

}

if (!value || value.byteLength === 0) {

continue;

}

const remaining = OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES - total;

if (remaining <= 0) {

reachedLimit = true;

break;

}

const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value;

total += chunk.byteLength;

text += decoder.decode(chunk, { stream: true });

if (total >= OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES) {

reachedLimit = true;

break;

}

}

text += decoder.decode();

} finally {

if (reachedLimit) {

// This provider module is browser-safe, so keep error-body capping on Web APIs.

await reader.cancel().catch(() => {});

}

try {

reader.releaseLock();

} catch {}

}

return text;

}

async function parseErrorResponse(

response: Response,

): Promise<{ message: string; friendlyMessage?: string }> {

const raw = await response.text();

const raw = await readChatGptResponsesErrorTextLimited(response);

let message = raw || response.statusText || "Request failed";

let friendlyMessage: string | undefined;