@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/bundle/dist/utils/providers/openai/openai-backend-protocol.js

@@ -0,0 +1,144 @@
+import os from "node:os";
+//#region src/utils/providers/openai/openai-backend-protocol.ts
+const CHATGPT_CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const CODEX_CLI_ORIGINATOR = "codex_cli_rs";
+const CODEX_CLI_VERSION = "0.147.0";
+function codexPlatform() {
+	const names = {
+		darwin: "Mac OS",
+		linux: "Linux",
+		win32: "Windows"
+	};
+	const terminal = process.env.TERM_PROGRAM;
+	const terminalVersion = process.env.TERM_PROGRAM_VERSION;
+	return {
+		osType: names[process.platform] ?? process.platform,
+		osVersion: os.release(),
+		architecture: process.arch,
+		terminal: terminal ? `${terminal}${terminalVersion ? `/${terminalVersion}` : ""}` : "unknown"
+	};
+}
+/** Matches the platform/terminal suffix emitted by the pinned Rust Codex CLI. */
+function codexCliUserAgent(platform = codexPlatform()) {
+	return `codex_cli_rs/${CODEX_CLI_VERSION} (${platform.osType} ${platform.osVersion}; ${platform.architecture}) ${platform.terminal}`;
+}
+function buildOpenAIResponsesRequest(options) {
+	const tools = options.tools ? [...options.tools] : [];
+	if (options.imageGeneration) tools.push(options.imageGeneration === true ? { type: "image_generation" } : {
+		type: "image_generation",
+		...options.imageGeneration
+	});
+	const text = options.verbosity || options.outputSchema ? {
+		...options.verbosity ? { verbosity: options.verbosity } : {},
+		...options.outputSchema ? { format: {
+			type: "json_schema",
+			strict: true,
+			schema: options.outputSchema.schema,
+			name: options.outputSchema.name ?? "codex_output_schema"
+		} } : {}
+	} : void 0;
+	return {
+		model: options.model,
+		...options.instructions ? { instructions: options.instructions } : {},
+		input: [...options.history],
+		...tools.length ? { tools } : {},
+		tool_choice: options.toolChoice ?? "auto",
+		parallel_tool_calls: options.parallelToolCalls ?? true,
+		reasoning: options.reasoning ?? null,
+		store: false,
+		stream: true,
+		include: ["reasoning.encrypted_content"],
+		...options.serviceTier ? { service_tier: options.serviceTier } : {},
+		...options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {},
+		...text ? { text } : {}
+	};
+}
+function buildCodexIdentityHeaders(accessToken, accountId, correlation) {
+	return {
+		Accept: "text/event-stream",
+		Authorization: `Bearer ${accessToken}`,
+		"ChatGPT-Account-ID": accountId,
+		"Content-Type": "application/json",
+		originator: CODEX_CLI_ORIGINATOR,
+		"User-Agent": codexCliUserAgent(),
+		...correlation?.sessionId ? { "session-id": correlation.sessionId } : {},
+		...correlation?.threadId ? { "thread-id": correlation.threadId } : {},
+		...correlation?.clientRequestId ? { "x-client-request-id": correlation.clientRequestId } : {}
+	};
+}
+var OpenAIProtocolError = class extends Error {
+	code;
+	status;
+	retryAfterMs;
+	constructor(message, code, status, retryAfterMs) {
+		super(message);
+		this.code = code;
+		this.status = status;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "OpenAIProtocolError";
+	}
+};
+function usageFrom(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const usage = value;
+	const inputDetails = usage.input_tokens_details ?? {};
+	const outputDetails = usage.output_tokens_details ?? {};
+	return {
+		inputTokens: Number(usage.input_tokens ?? 0),
+		cachedInputTokens: Number(inputDetails.cached_tokens ?? 0),
+		outputTokens: Number(usage.output_tokens ?? 0),
+		reasoningTokens: Number(outputDetails.reasoning_tokens ?? 0),
+		totalTokens: Number(usage.total_tokens ?? 0)
+	};
+}
+function normalizeOpenAIEvent(raw) {
+	if (!raw || typeof raw !== "object") return void 0;
+	const event = raw;
+	const type = String(event.type ?? "");
+	if (type === "response.created") {
+		const response = event.response;
+		return {
+			type: "created",
+			...response?.id ? { responseId: String(response.id) } : {}
+		};
+	}
+	if (type === "response.output_text.delta" && typeof event.delta === "string") return {
+		type: "text-delta",
+		text: event.delta
+	};
+	if ((type === "response.output_item.added" || type === "response.output_item.done") && event.item && typeof event.item === "object") {
+		const item = event.item;
+		if (item.type === "image_generation_call" && typeof item.result === "string") return {
+			type: "image",
+			...typeof item.id === "string" ? { id: item.id } : {},
+			base64: item.result,
+			mimeType: "image/png",
+			...typeof item.revised_prompt === "string" ? { revisedPrompt: item.revised_prompt } : typeof item.revisedPrompt === "string" ? { revisedPrompt: item.revisedPrompt } : {}
+		};
+		return {
+			type: "output-item",
+			item
+		};
+	}
+	if (type === "response.completed") {
+		const response = event.response ?? {};
+		return {
+			type: "completed",
+			responseId: String(response.id ?? ""),
+			...response.usage ? { usage: usageFrom(response.usage) } : {},
+			...typeof response.model === "string" ? { model: response.model } : {}
+		};
+	}
+	if (type === "error" || type === "response.failed" || type === "response.incomplete") {
+		const source = event.error ?? event.response ?? event;
+		const nested = source.error ?? source;
+		return {
+			type: "error",
+			error: new OpenAIProtocolError(String(nested.message ?? `OpenAI stream ended with ${type}`), typeof nested.code === "string" ? nested.code : void 0)
+		};
+	}
+}
+//#endregion
+export { CHATGPT_CODEX_RESPONSES_URL, CODEX_CLI_ORIGINATOR, CODEX_CLI_VERSION, OpenAIProtocolError, buildCodexIdentityHeaders, buildOpenAIResponsesRequest, codexCliUserAgent, normalizeOpenAIEvent };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-backend-protocol.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-backend-protocol.ts"],"sourcesContent":["import os from \"node:os\";\n\nexport const CHATGPT_CODEX_RESPONSES_URL =\n  \"https://chatgpt.com/backend-api/codex/responses\" as const;\n\nexport const CODEX_CLI_ORIGINATOR = \"codex_cli_rs\" as const;\nexport const CODEX_CLI_VERSION = \"0.147.0\" as const;\n\nexport interface CodexUserAgentPlatform {\n  osType: string;\n  osVersion: string;\n  architecture: string;\n  terminal: string;\n}\n\nfunction codexPlatform(): CodexUserAgentPlatform {\n  const names: Partial<Record<NodeJS.Platform, string>> = {\n    darwin: \"Mac OS\",\n    linux: \"Linux\",\n    win32: \"Windows\",\n  };\n  const terminal = process.env.TERM_PROGRAM;\n  const terminalVersion = process.env.TERM_PROGRAM_VERSION;\n  return {\n    osType: names[process.platform] ?? process.platform,\n    osVersion: os.release(),\n    architecture: process.arch,\n    terminal: terminal ? `${terminal}${terminalVersion ? `/${terminalVersion}` : \"\"}` : \"unknown\",\n  };\n}\n\n/** Matches the platform/terminal suffix emitted by the pinned Rust Codex CLI. */\nexport function codexCliUserAgent(platform: CodexUserAgentPlatform = codexPlatform()): string {\n  return `codex_cli_rs/${CODEX_CLI_VERSION} (${platform.osType} ${platform.osVersion}; ${platform.architecture}) ${platform.terminal}`;\n}\n\nexport type JsonValue =\n  | null\n  | boolean\n  | number\n  | string\n  | JsonValue[]\n  | { [key: string]: JsonValue };\n\n/** Raw Responses API items. Keeping these opaque preserves the complete conversation history. */\nexport type OpenAIResponseItem = Record<string, unknown>;\n\nexport interface OpenAIOutputSchema {\n  name?: string;\n  schema: JsonValue;\n}\n\nexport interface OpenAIResponsesOptions {\n  model: string;\n  instructions?: string;\n  history: readonly OpenAIResponseItem[];\n  tools?: readonly OpenAIResponseItem[];\n  toolChoice?: string | OpenAIResponseItem;\n  parallelToolCalls?: boolean;\n  reasoning?: {\n    effort?: \"none\" | \"minimal\" | \"low\" | \"medium\" | \"high\" | \"xhigh\";\n    summary?: \"auto\" | \"concise\" | \"detailed\";\n  };\n  verbosity?: \"low\" | \"medium\" | \"high\";\n  serviceTier?: string;\n  promptCacheKey?: string;\n  outputSchema?: OpenAIOutputSchema;\n  imageGeneration?: boolean | OpenAIResponseItem;\n}\n\nexport interface OpenAIResponsesRequest {\n  model: string;\n  instructions?: string;\n  input: OpenAIResponseItem[];\n  tools?: OpenAIResponseItem[];\n  tool_choice: string | OpenAIResponseItem;\n  parallel_tool_calls: boolean;\n  reasoning: OpenAIResponsesOptions[\"reasoning\"] | null;\n  store: false;\n  stream: true;\n  include: string[];\n  service_tier?: string;\n  prompt_cache_key?: string;\n  text?: {\n    verbosity?: \"low\" | \"medium\" | \"high\";\n    format?: {\n      type: \"json_schema\";\n      strict: true;\n      schema: JsonValue;\n      name: string;\n    };\n  };\n}\n\nexport function buildOpenAIResponsesRequest(\n  options: OpenAIResponsesOptions,\n): OpenAIResponsesRequest {\n  const tools = options.tools ? [...options.tools] : [];\n  if (options.imageGeneration) {\n    tools.push(\n      options.imageGeneration === true\n        ? { type: \"image_generation\" }\n        : { type: \"image_generation\", ...options.imageGeneration },\n    );\n  }\n\n  const text =\n    options.verbosity || options.outputSchema\n      ? {\n          ...(options.verbosity ? { verbosity: options.verbosity } : {}),\n          ...(options.outputSchema\n            ? {\n                format: {\n                  type: \"json_schema\" as const,\n                  strict: true as const,\n                  schema: options.outputSchema.schema,\n                  name: options.outputSchema.name ?? \"codex_output_schema\",\n                },\n              }\n            : {}),\n        }\n      : undefined;\n\n  return {\n    model: options.model,\n    ...(options.instructions ? { instructions: options.instructions } : {}),\n    // Copy the array, not its items: raw items must arrive byte-for-byte equivalent.\n    input: [...options.history],\n    ...(tools.length ? { tools } : {}),\n    tool_choice: options.toolChoice ?? \"auto\",\n    parallel_tool_calls: options.parallelToolCalls ?? true,\n    reasoning: options.reasoning ?? null,\n    store: false,\n    stream: true,\n    include: [\"reasoning.encrypted_content\"],\n    ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),\n    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),\n    ...(text ? { text } : {}),\n  };\n}\n\nexport function buildCodexIdentityHeaders(\n  accessToken: string,\n  accountId: string,\n  correlation?: { sessionId?: string; threadId?: string; clientRequestId?: string },\n): Record<string, string> {\n  return {\n    Accept: \"text/event-stream\",\n    Authorization: `Bearer ${accessToken}`,\n    \"ChatGPT-Account-ID\": accountId,\n    \"Content-Type\": \"application/json\",\n    originator: CODEX_CLI_ORIGINATOR,\n    \"User-Agent\": codexCliUserAgent(),\n    ...(correlation?.sessionId ? { \"session-id\": correlation.sessionId } : {}),\n    ...(correlation?.threadId ? { \"thread-id\": correlation.threadId } : {}),\n    ...(correlation?.clientRequestId ? { \"x-client-request-id\": correlation.clientRequestId } : {}),\n  };\n}\n\nexport interface OpenAIUsage {\n  inputTokens: number;\n  cachedInputTokens: number;\n  outputTokens: number;\n  reasoningTokens: number;\n  totalTokens: number;\n}\n\nexport type OpenAINormalizedEvent =\n  | { type: \"created\"; responseId?: string }\n  | { type: \"text-delta\"; text: string }\n  | { type: \"image\"; id?: string; base64: string; mimeType: \"image/png\"; revisedPrompt?: string }\n  | { type: \"output-item\"; item: OpenAIResponseItem }\n  | { type: \"completed\"; responseId: string; usage?: OpenAIUsage; model?: string }\n  | { type: \"error\"; error: OpenAIProtocolError };\n\nexport class OpenAIProtocolError extends Error {\n  constructor(\n    message: string,\n    public readonly code?: string,\n    public readonly status?: number,\n    public readonly retryAfterMs?: number,\n  ) {\n    super(message);\n    this.name = \"OpenAIProtocolError\";\n  }\n}\n\nfunction usageFrom(value: unknown): OpenAIUsage | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const usage = value as Record<string, unknown>;\n  const inputDetails = (usage.input_tokens_details ?? {}) as Record<string, unknown>;\n  const outputDetails = (usage.output_tokens_details ?? {}) as Record<string, unknown>;\n  return {\n    inputTokens: Number(usage.input_tokens ?? 0),\n    cachedInputTokens: Number(inputDetails.cached_tokens ?? 0),\n    outputTokens: Number(usage.output_tokens ?? 0),\n    reasoningTokens: Number(outputDetails.reasoning_tokens ?? 0),\n    totalTokens: Number(usage.total_tokens ?? 0),\n  };\n}\n\nexport function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | undefined {\n  if (!raw || typeof raw !== \"object\") return undefined;\n  const event = raw as Record<string, unknown>;\n  const type = String(event.type ?? \"\");\n  if (type === \"response.created\") {\n    const response = event.response as Record<string, unknown> | undefined;\n    return { type: \"created\", ...(response?.id ? { responseId: String(response.id) } : {}) };\n  }\n  if (type === \"response.output_text.delta\" && typeof event.delta === \"string\") {\n    return { type: \"text-delta\", text: event.delta };\n  }\n  if (\n    (type === \"response.output_item.added\" || type === \"response.output_item.done\") &&\n    event.item &&\n    typeof event.item === \"object\"\n  ) {\n    const item = event.item as OpenAIResponseItem;\n    if (item.type === \"image_generation_call\" && typeof item.result === \"string\") {\n      return {\n        type: \"image\",\n        ...(typeof item.id === \"string\" ? { id: item.id } : {}),\n        base64: item.result,\n        mimeType: \"image/png\",\n        ...(typeof item.revised_prompt === \"string\"\n          ? { revisedPrompt: item.revised_prompt }\n          : typeof item.revisedPrompt === \"string\"\n            ? { revisedPrompt: item.revisedPrompt }\n            : {}),\n      };\n    }\n    return { type: \"output-item\", item };\n  }\n  if (type === \"response.completed\") {\n    const response = (event.response ?? {}) as Record<string, unknown>;\n    return {\n      type: \"completed\",\n      responseId: String(response.id ?? \"\"),\n      ...(response.usage ? { usage: usageFrom(response.usage) } : {}),\n      ...(typeof response.model === \"string\" ? { model: response.model } : {}),\n    };\n  }\n  if (type === \"error\" || type === \"response.failed\" || type === \"response.incomplete\") {\n    const source = (event.error ?? event.response ?? event) as Record<string, unknown>;\n    const nested = (source.error ?? source) as Record<string, unknown>;\n    return {\n      type: \"error\",\n      error: new OpenAIProtocolError(\n        String(nested.message ?? `OpenAI stream ended with ${type}`),\n        typeof nested.code === \"string\" ? nested.code : undefined,\n      ),\n    };\n  }\n  return undefined;\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/openai/openai-constants.js

@@ -1,9 +1,11 @@
 //#region src/utils/providers/openai/openai-constants.ts
 const OPENAI_ISSUER = "https://auth.openai.com";
 const OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const OPENAI_AUTHORIZE_URL = `${OPENAI_ISSUER}/oauth/authorize`;
 const OPENAI_TOKEN_URL = `${OPENAI_ISSUER}/oauth/token`;
 const OPENAI_SCOPES = "openid profile email offline_access api.connectors.read api.connectors.invoke";
+const OPENAI_ORIGINATOR = "codex_cli_rs";
 //#endregion
-export { OPENAI_CLIENT_ID, OPENAI_ISSUER, OPENAI_SCOPES, OPENAI_TOKEN_URL };
+export { OPENAI_AUTHORIZE_URL, OPENAI_CLIENT_ID, OPENAI_ISSUER, OPENAI_ORIGINATOR, OPENAI_SCOPES, OPENAI_TOKEN_URL };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFpLWNvbnN0YW50cy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvcHJvdmlkZXJzL29wZW5haS9vcGVuYWktY29uc3RhbnRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBPUEVOQUlfSVNTVUVSID0gXCJodHRwczovL2F1dGgub3BlbmFpLmNvbVwiO1xuZXhwb3J0IGNvbnN0IE9QRU5BSV9DTElFTlRfSUQgPSBcImFwcF9FTW9hbUVFWjczZjBDa1hhWHA3aHJhbm5cIjtcbmV4cG9ydCBjb25zdCBPUEVOQUlfVE9LRU5fVVJMID0gYCR7T1BFTkFJX0lTU1VFUn0vb2F1dGgvdG9rZW5gO1xuZXhwb3J0IGNvbnN0IE9QRU5BSV9TQ09QRVMgPVxuICBcIm9wZW5pZCBwcm9maWxlIGVtYWlsIG9mZmxpbmVfYWNjZXNzIGFwaS5jb25uZWN0b3JzLnJlYWQgYXBpLmNvbm5lY3RvcnMuaW52b2tlXCI7XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxNQUFhLGdCQUFnQjtBQUM3QixNQUFhLG1CQUFtQjtBQUNoQyxNQUFhLG1CQUFtQixHQUFHLGNBQWM7QUFDakQsTUFBYSxnQkFDWCJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFpLWNvbnN0YW50cy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvcHJvdmlkZXJzL29wZW5haS9vcGVuYWktY29uc3RhbnRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBPUEVOQUlfSVNTVUVSID0gXCJodHRwczovL2F1dGgub3BlbmFpLmNvbVwiO1xuZXhwb3J0IGNvbnN0IE9QRU5BSV9DTElFTlRfSUQgPSBcImFwcF9FTW9hbUVFWjczZjBDa1hhWHA3aHJhbm5cIjtcbmV4cG9ydCBjb25zdCBPUEVOQUlfQVVUSE9SSVpFX1VSTCA9IGAke09QRU5BSV9JU1NVRVJ9L29hdXRoL2F1dGhvcml6ZWA7XG5leHBvcnQgY29uc3QgT1BFTkFJX1RPS0VOX1VSTCA9IGAke09QRU5BSV9JU1NVRVJ9L29hdXRoL3Rva2VuYDtcbmV4cG9ydCBjb25zdCBPUEVOQUlfU0NPUEVTID1cbiAgXCJvcGVuaWQgcHJvZmlsZSBlbWFpbCBvZmZsaW5lX2FjY2VzcyBhcGkuY29ubmVjdG9ycy5yZWFkIGFwaS5jb25uZWN0b3JzLmludm9rZVwiO1xuZXhwb3J0IGNvbnN0IE9QRU5BSV9PUklHSU5BVE9SID0gXCJjb2RleF9jbGlfcnNcIjtcbiJdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQWEsZ0JBQWdCO0FBQzdCLE1BQWEsbUJBQW1CO0FBQ2hDLE1BQWEsdUJBQXVCLEdBQUcsY0FBYztBQUNyRCxNQUFhLG1CQUFtQixHQUFHLGNBQWM7QUFDakQsTUFBYSxnQkFDWDtBQUNGLE1BQWEsb0JBQW9CIn0=

package/bundle/dist/utils/providers/openai/openai-direct-client.js

@@ -0,0 +1,327 @@
+import { CHATGPT_CODEX_RESPONSES_URL, OpenAIProtocolError, buildCodexIdentityHeaders, buildOpenAIResponsesRequest, normalizeOpenAIEvent } from "./openai-backend-protocol.js";
+import { normalizeOpenAISSE } from "./openai-sse.js";
+import crypto from "node:crypto";
+import WsClient from "ws";
+//#region src/utils/providers/openai/openai-direct-client.ts
+const MAX_BUFFERED_SOCKET_RECORDS = 1600;
+function websocketUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch (error) {
+		throw new OpenAIProtocolError(`Invalid OpenAI Responses URL: ${String(error)}`);
+	}
+	parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:";
+	return parsed.toString();
+}
+function rawDataText(data) {
+	if (Array.isArray(data)) return Buffer.concat(data).toString();
+	if (data instanceof ArrayBuffer) return Buffer.from(new Uint8Array(data)).toString();
+	return Buffer.from(data).toString();
+}
+function socketEvents(socket, signal) {
+	const records = [];
+	const waiters = [];
+	let active = true;
+	const push = (record) => {
+		if (!active) return;
+		const waiter = waiters.shift();
+		if (waiter) waiter(record);
+		else if (records.length < MAX_BUFFERED_SOCKET_RECORDS) records.push(record);
+		else {
+			active = false;
+			records.length = 0;
+			socket.terminate();
+			const overflow = {
+				kind: "error",
+				error: new OpenAIProtocolError(`OpenAI WebSocket exceeded the ${MAX_BUFFERED_SOCKET_RECORDS}-record receive buffer`, "websocket_backpressure")
+			};
+			const overflowWaiter = waiters.shift();
+			if (overflowWaiter) overflowWaiter(overflow);
+			else records.push(overflow);
+		}
+	};
+	const onOpen = () => push({ kind: "open" });
+	const onMessage = (data, isBinary) => push({
+		kind: "message",
+		data,
+		isBinary
+	});
+	const onClose = (code, reason) => push({
+		kind: "close",
+		code,
+		reason: reason.toString()
+	});
+	const onError = (error) => push({
+		kind: "error",
+		error
+	});
+	const onUnexpectedResponse = (_request, response) => push({
+		kind: "rejected",
+		status: response.statusCode
+	});
+	socket.on("open", onOpen);
+	socket.on("message", onMessage);
+	socket.on("close", onClose);
+	socket.on("error", onError);
+	socket.on("unexpected-response", onUnexpectedResponse);
+	const onAbort = () => {
+		socket.terminate();
+		push({
+			kind: "error",
+			error: abortError(signal)
+		});
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	return {
+		next: () => records.length ? Promise.resolve(records.shift()) : new Promise((resolve) => waiters.push(resolve)),
+		cleanup: () => {
+			active = false;
+			signal?.removeEventListener("abort", onAbort);
+			socket.off("open", onOpen);
+			socket.off("message", onMessage);
+			socket.off("close", onClose);
+			socket.off("error", onError);
+			socket.off("unexpected-response", onUnexpectedResponse);
+			records.length = 0;
+			const closed = {
+				kind: "error",
+				error: new OpenAIProtocolError("OpenAI WebSocket event stream was closed")
+			};
+			for (const waiter of waiters.splice(0)) waiter(closed);
+		},
+		detachAbort: () => signal?.removeEventListener("abort", onAbort)
+	};
+}
+function abortError(signal) {
+	return signal?.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError");
+}
+async function nextPooledRecord(events, socket, signal) {
+	if (!signal) return events.next();
+	if (signal.aborted) throw abortError(signal);
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			socket.terminate();
+			reject(abortError(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		events.next().then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", onAbort);
+		});
+	});
+}
+function cacheAffinityUuid(key) {
+	const hex = crypto.createHash("sha256").update(key).digest("hex").slice(0, 32).split("");
+	hex[12] = "4";
+	hex[16] = (Number.parseInt(hex[16], 16) & 3 | 8).toString(16);
+	return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20).join("")}`;
+}
+var OpenAIWebSocketTransport = class OpenAIWebSocketTransport {
+	static MAX_AFFINITY_CONNECTIONS = 16;
+	credentials;
+	refreshCredentials;
+	webSocketFactory;
+	affinityConnections = /* @__PURE__ */ new Map();
+	busyAffinities = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.credentials = options.credentials;
+		this.refreshCredentials = options.refreshCredentials;
+		this.webSocketFactory = options.webSocketFactory ?? ((url, wsOptions) => new WsClient(url, wsOptions));
+	}
+	stream(request) {
+		return this.run(request);
+	}
+	close() {
+		for (const { socket, events } of this.affinityConnections.values()) {
+			events.cleanup();
+			socket.close(1e3, "transport closed");
+		}
+		this.affinityConnections.clear();
+		this.busyAffinities.clear();
+	}
+	/**
+	* 캐시에 연결을 등록한다. 자리가 없으면 유휴 연결만 축출하고, 전부 사용 중이면
+	* 진행 중인 응답을 끊는 대신 등록을 포기한다(false → 이 요청은 일회성 소켓으로 처리).
+	*/
+	rememberAffinityConnection(threadId, connection) {
+		if (!this.affinityConnections.has(threadId) && this.affinityConnections.size >= OpenAIWebSocketTransport.MAX_AFFINITY_CONNECTIONS) {
+			const idleKey = [...this.affinityConnections.keys()].find((key) => !this.busyAffinities.has(key));
+			if (idleKey === void 0) return false;
+			const idle = this.affinityConnections.get(idleKey);
+			idle.events.cleanup();
+			idle.socket.close(1e3, "affinity cache evicted");
+			this.affinityConnections.delete(idleKey);
+		}
+		this.affinityConnections.set(threadId, connection);
+		const drop = () => {
+			connection.closed = true;
+			if (this.busyAffinities.has(threadId)) return;
+			if (this.affinityConnections.get(threadId) !== connection) return;
+			this.affinityConnections.delete(threadId);
+			connection.events.cleanup();
+		};
+		connection.socket.on("close", drop);
+		connection.socket.on("error", drop);
+		return true;
+	}
+	async *run(request) {
+		let refreshed = false;
+		while (true) {
+			if (request.signal?.aborted) throw abortError(request.signal);
+			const retainConnection = request.body.prompt_cache_key !== void 0 && !this.busyAffinities.has(request.threadId);
+			if (retainConnection) this.busyAffinities.add(request.threadId);
+			const entry = retainConnection ? this.affinityConnections.get(request.threadId) : void 0;
+			if (entry?.closed) {
+				this.affinityConnections.delete(request.threadId);
+				entry.events.cleanup();
+			}
+			const cached = entry?.closed ? void 0 : entry;
+			let retained = retainConnection;
+			const socket = cached?.socket ?? this.webSocketFactory(websocketUrl("https://chatgpt.com/backend-api/codex/responses"), { headers: {
+				...buildCodexIdentityHeaders(this.credentials.accessToken, this.credentials.accountId, {
+					sessionId: request.sessionId,
+					threadId: request.threadId,
+					clientRequestId: request.clientRequestId
+				}),
+				"OpenAI-Beta": "responses_websockets=2026-02-06"
+			} });
+			const events = cached?.events ?? socketEvents(socket, request.signal);
+			let completed = false;
+			try {
+				if (!cached) {
+					const handshake = await events.next();
+					if (handshake.kind === "rejected" && handshake.status === 401 && !refreshed && this.refreshCredentials) {
+						socket.terminate();
+						this.credentials = await this.refreshCredentials();
+						refreshed = true;
+						continue;
+					}
+					if (handshake.kind === "rejected") throw new OpenAIProtocolError(`OpenAI WebSocket handshake rejected${handshake.status ? ` with HTTP ${handshake.status}` : ""}`, void 0, handshake.status);
+					if (handshake.kind === "error") throw handshake.error;
+					if (handshake.kind !== "open") throw new OpenAIProtocolError("OpenAI WebSocket closed before the handshake completed");
+					if (retainConnection) retained = this.rememberAffinityConnection(request.threadId, {
+						socket,
+						events
+					});
+				}
+				await new Promise((resolve, reject) => {
+					socket.send(JSON.stringify({
+						type: "response.create",
+						...request.body
+					}), (error) => error ? reject(error) : resolve());
+				});
+				while (true) {
+					const record = cached ? await nextPooledRecord(events, socket, request.signal) : await events.next();
+					if (record.kind === "message") {
+						if (record.isBinary) throw new OpenAIProtocolError("OpenAI WebSocket sent an unexpected binary message");
+						let raw;
+						try {
+							raw = JSON.parse(rawDataText(record.data));
+						} catch {
+							throw new OpenAIProtocolError("OpenAI WebSocket sent invalid JSON");
+						}
+						const event = normalizeOpenAIEvent(raw);
+						if (!event) continue;
+						if (event.type === "completed") {
+							completed = true;
+							if (retained) events.detachAbort();
+							else socket.close(1e3, "response completed");
+							yield event;
+							return;
+						}
+						yield event;
+						if (event.type === "error") throw event.error;
+					} else if (record.kind === "error") throw record.error;
+					else if (record.kind === "close") throw new OpenAIProtocolError(`OpenAI WebSocket closed before a terminal response event (${record.code}${record.reason ? `: ${record.reason}` : ""})`);
+					else throw new OpenAIProtocolError("OpenAI WebSocket emitted an unexpected handshake event");
+				}
+			} finally {
+				if (!completed || !retained) {
+					if (retained) this.affinityConnections.delete(request.threadId);
+					events.cleanup();
+					if (!completed) socket.terminate();
+				}
+				if (retainConnection) this.busyAffinities.delete(request.threadId);
+			}
+		}
+	}
+};
+async function responseError(response) {
+	const text = await response.text().catch(() => "");
+	let message = text || response.statusText || `HTTP ${response.status}`;
+	let code;
+	try {
+		const parsed = JSON.parse(text);
+		const error = parsed.error;
+		message = (typeof error === "object" ? error.message : void 0) ?? parsed.message ?? (typeof error === "string" ? error : message);
+		code = (typeof error === "object" ? error.code : void 0) ?? parsed.code;
+	} catch {
+		code = void 0;
+	}
+	return new OpenAIProtocolError(message, code, response.status);
+}
+var OpenAIHttpsTransport = class {
+	credentials;
+	fetchImpl;
+	refreshCredentials;
+	constructor(options) {
+		this.credentials = options.credentials;
+		this.fetchImpl = options.fetch ?? fetch;
+		this.refreshCredentials = options.refreshCredentials;
+	}
+	stream(request) {
+		return this.run(request);
+	}
+	async *run(request) {
+		let refreshed = false;
+		while (true) {
+			const response = await this.fetchImpl(CHATGPT_CODEX_RESPONSES_URL, {
+				method: "POST",
+				headers: buildCodexIdentityHeaders(this.credentials.accessToken, this.credentials.accountId, {
+					sessionId: request.sessionId,
+					threadId: request.threadId,
+					clientRequestId: request.clientRequestId
+				}),
+				body: JSON.stringify(request.body),
+				signal: request.signal
+			});
+			if (response.status === 401 && !refreshed && this.refreshCredentials) {
+				await response.body?.cancel();
+				this.credentials = await this.refreshCredentials();
+				refreshed = true;
+				continue;
+			}
+			if (!response.ok) throw await responseError(response);
+			if (!response.body) throw new OpenAIProtocolError("OpenAI response had no body");
+			for await (const event of normalizeOpenAISSE(response.body)) yield event;
+			return;
+		}
+	}
+};
+var OpenAIDirectClient = class {
+	transport;
+	constructor(options) {
+		this.transport = options.transport ?? (options.transportKind === "websocket" ? new OpenAIWebSocketTransport(options) : new OpenAIHttpsTransport(options));
+	}
+	responses(options, signal) {
+		const clientRequestId = crypto.randomUUID();
+		const affinityId = options.promptCacheKey ? cacheAffinityUuid(options.promptCacheKey) : clientRequestId;
+		return this.transport.stream({
+			body: buildOpenAIResponsesRequest(options.promptCacheKey ? {
+				...options,
+				promptCacheKey: affinityId
+			} : options),
+			signal,
+			sessionId: affinityId,
+			threadId: affinityId,
+			clientRequestId
+		});
+	}
+	close() {
+		this.transport.close?.();
+	}
+};
+//#endregion
+export { OpenAIDirectClient, OpenAIHttpsTransport, OpenAIWebSocketTransport };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-direct-client.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-direct-client.ts"],"sourcesContent":["import crypto from \"node:crypto\";\n\nimport WsClient, { type ClientOptions, type RawData } from \"ws\";\n\nimport {\n  buildCodexIdentityHeaders,\n  buildOpenAIResponsesRequest,\n  CHATGPT_CODEX_RESPONSES_URL,\n  normalizeOpenAIEvent,\n  OpenAIProtocolError,\n  type OpenAINormalizedEvent,\n  type OpenAIResponsesOptions,\n  type OpenAIResponsesRequest,\n} from \"./openai-backend-protocol\";\nimport { normalizeOpenAISSE, type OpenAIEventStream } from \"./openai-sse\";\n\nexport interface OpenAIDirectCredentials {\n  accessToken: string;\n  accountId: string;\n}\n\nexport interface OpenAITransportRequest {\n  body: OpenAIResponsesRequest;\n  signal?: AbortSignal;\n  sessionId: string;\n  threadId: string;\n  clientRequestId: string;\n}\n\n/** Transport-independent streaming interface; HTTPS is the first implementation. */\nexport interface OpenAIResponsesTransport {\n  stream(request: OpenAITransportRequest): OpenAIEventStream;\n  close?(): void;\n}\n\nexport interface OpenAIHttpsTransportOptions {\n  credentials: OpenAIDirectCredentials;\n  fetch?: typeof fetch;\n  refreshCredentials?: () => Promise<OpenAIDirectCredentials>;\n}\n\nexport interface OpenAIWebSocketLike {\n  on(event: \"open\", listener: () => void): this;\n  on(event: \"message\", listener: (data: RawData, isBinary: boolean) => void): this;\n  on(event: \"close\", listener: (code: number, reason: Buffer) => void): this;\n  on(event: \"error\", listener: (error: Error) => void): this;\n  on(\n    event: \"unexpected-response\",\n    listener: (request: unknown, response: { statusCode?: number }) => void,\n  ): this;\n  off(event: string, listener: (...args: never[]) => void): this;\n  send(data: string, callback?: (error?: Error) => void): void;\n  close(code?: number, reason?: string): void;\n  terminate(): void;\n}\n\nexport type OpenAIWebSocketFactory = (url: string, options: ClientOptions) => OpenAIWebSocketLike;\n\nexport interface OpenAIWebSocketTransportOptions extends OpenAIHttpsTransportOptions {\n  webSocketFactory?: OpenAIWebSocketFactory;\n}\n\ntype SocketRecord =\n  | { kind: \"open\" }\n  | { kind: \"message\"; data: RawData; isBinary: boolean }\n  | { kind: \"close\"; code: number; reason: string }\n  | { kind: \"error\"; error: Error }\n  | { kind: \"rejected\"; status?: number };\n\nconst MAX_BUFFERED_SOCKET_RECORDS = 1600;\n\nfunction websocketUrl(url: string): string {\n  let parsed: URL;\n  try {\n    parsed = new URL(url);\n  } catch (error) {\n    throw new OpenAIProtocolError(`Invalid OpenAI Responses URL: ${String(error)}`);\n  }\n  parsed.protocol = parsed.protocol === \"https:\" ? \"wss:\" : \"ws:\";\n  return parsed.toString();\n}\n\nfunction rawDataText(data: RawData): string {\n  if (Array.isArray(data)) return Buffer.concat(data).toString();\n  if (data instanceof ArrayBuffer) return Buffer.from(new Uint8Array(data)).toString();\n  return Buffer.from(data).toString();\n}\n\nfunction socketEvents(socket: OpenAIWebSocketLike, signal?: AbortSignal) {\n  const records: SocketRecord[] = [];\n  const waiters: Array<(record: SocketRecord) => void> = [];\n  let active = true;\n  const push = (record: SocketRecord) => {\n    if (!active) return;\n    const waiter = waiters.shift();\n    if (waiter) waiter(record);\n    else if (records.length < MAX_BUFFERED_SOCKET_RECORDS) records.push(record);\n    else {\n      active = false;\n      records.length = 0;\n      socket.terminate();\n      const overflow = {\n        kind: \"error\" as const,\n        error: new OpenAIProtocolError(\n          `OpenAI WebSocket exceeded the ${MAX_BUFFERED_SOCKET_RECORDS}-record receive buffer`,\n          \"websocket_backpressure\",\n        ),\n      };\n      const overflowWaiter = waiters.shift();\n      if (overflowWaiter) overflowWaiter(overflow);\n      else records.push(overflow);\n    }\n  };\n  const onOpen = () => push({ kind: \"open\" });\n  const onMessage = (data: RawData, isBinary: boolean) => push({ kind: \"message\", data, isBinary });\n  const onClose = (code: number, reason: Buffer) =>\n    push({ kind: \"close\", code, reason: reason.toString() });\n  const onError = (error: Error) => push({ kind: \"error\", error });\n  const onUnexpectedResponse = (_request: unknown, response: { statusCode?: number }) =>\n    push({ kind: \"rejected\", status: response.statusCode });\n  socket.on(\"open\", onOpen);\n  socket.on(\"message\", onMessage);\n  socket.on(\"close\", onClose);\n  socket.on(\"error\", onError);\n  socket.on(\"unexpected-response\", onUnexpectedResponse);\n  const onAbort = () => {\n    socket.terminate();\n    push({ kind: \"error\", error: abortError(signal) });\n  };\n  signal?.addEventListener(\"abort\", onAbort, { once: true });\n  return {\n    next: () =>\n      records.length\n        ? Promise.resolve(records.shift()!)\n        : new Promise<SocketRecord>((resolve) => waiters.push(resolve)),\n    cleanup: () => {\n      active = false;\n      signal?.removeEventListener(\"abort\", onAbort);\n      socket.off(\"open\", onOpen);\n      socket.off(\"message\", onMessage);\n      socket.off(\"close\", onClose);\n      socket.off(\"error\", onError);\n      socket.off(\"unexpected-response\", onUnexpectedResponse);\n      records.length = 0;\n      const closed = {\n        kind: \"error\" as const,\n        error: new OpenAIProtocolError(\"OpenAI WebSocket event stream was closed\"),\n      };\n      for (const waiter of waiters.splice(0)) waiter(closed);\n    },\n    detachAbort: () => signal?.removeEventListener(\"abort\", onAbort),\n  };\n}\n\nfunction abortError(signal?: AbortSignal): Error {\n  return signal?.reason instanceof Error\n    ? signal.reason\n    : new DOMException(\"Aborted\", \"AbortError\");\n}\n\nasync function nextPooledRecord(\n  events: ReturnType<typeof socketEvents>,\n  socket: OpenAIWebSocketLike,\n  signal?: AbortSignal,\n): Promise<SocketRecord> {\n  if (!signal) return events.next();\n  if (signal.aborted) throw abortError(signal);\n  return new Promise<SocketRecord>((resolve, reject) => {\n    const onAbort = () => {\n      socket.terminate();\n      reject(abortError(signal));\n    };\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    void events\n      .next()\n      .then(resolve, reject)\n      .finally(() => {\n        signal.removeEventListener(\"abort\", onAbort);\n      });\n  });\n}\n\nfunction cacheAffinityUuid(key: string): string {\n  const hex = crypto.createHash(\"sha256\").update(key).digest(\"hex\").slice(0, 32).split(\"\");\n  hex[12] = \"4\";\n  hex[16] = ((Number.parseInt(hex[16]!, 16) & 0x3) | 0x8).toString(16);\n  return `${hex.slice(0, 8).join(\"\")}-${hex.slice(8, 12).join(\"\")}-${hex.slice(12, 16).join(\"\")}-${hex.slice(16, 20).join(\"\")}-${hex.slice(20).join(\"\")}`;\n}\n\ntype AffinityConnection = {\n  socket: OpenAIWebSocketLike;\n  events: ReturnType<typeof socketEvents>;\n  closed?: boolean;\n};\n\nexport class OpenAIWebSocketTransport implements OpenAIResponsesTransport {\n  private static readonly MAX_AFFINITY_CONNECTIONS = 16;\n  private credentials: OpenAIDirectCredentials;\n  private readonly refreshCredentials?: () => Promise<OpenAIDirectCredentials>;\n  private readonly webSocketFactory: OpenAIWebSocketFactory;\n  private readonly affinityConnections = new Map<string, AffinityConnection>();\n  private readonly busyAffinities = new Set<string>();\n\n  constructor(options: OpenAIWebSocketTransportOptions) {\n    this.credentials = options.credentials;\n    this.refreshCredentials = options.refreshCredentials;\n    this.webSocketFactory =\n      options.webSocketFactory ?? ((url, wsOptions) => new WsClient(url, wsOptions));\n  }\n\n  stream(request: OpenAITransportRequest): OpenAIEventStream {\n    return this.run(request);\n  }\n\n  close(): void {\n    for (const { socket, events } of this.affinityConnections.values()) {\n      events.cleanup();\n      socket.close(1000, \"transport closed\");\n    }\n    this.affinityConnections.clear();\n    this.busyAffinities.clear();\n  }\n\n  /**\n   * 캐시에 연결을 등록한다. 자리가 없으면 유휴 연결만 축출하고, 전부 사용 중이면\n   * 진행 중인 응답을 끊는 대신 등록을 포기한다(false → 이 요청은 일회성 소켓으로 처리).\n   */\n  private rememberAffinityConnection(threadId: string, connection: AffinityConnection): boolean {\n    if (\n      !this.affinityConnections.has(threadId) &&\n      this.affinityConnections.size >= OpenAIWebSocketTransport.MAX_AFFINITY_CONNECTIONS\n    ) {\n      const idleKey = [...this.affinityConnections.keys()].find(\n        (key) => !this.busyAffinities.has(key),\n      );\n      if (idleKey === undefined) return false;\n      const idle = this.affinityConnections.get(idleKey)!;\n      idle.events.cleanup();\n      idle.socket.close(1000, \"affinity cache evicted\");\n      this.affinityConnections.delete(idleKey);\n    }\n    this.affinityConnections.set(threadId, connection);\n    // 유휴 상태에서 backend 가 끊은 소켓을 다음 요청이 집어들지 않도록 캐시에서 제거한다.\n    const drop = () => {\n      connection.closed = true;\n      if (this.busyAffinities.has(threadId)) return;\n      if (this.affinityConnections.get(threadId) !== connection) return;\n      this.affinityConnections.delete(threadId);\n      connection.events.cleanup();\n    };\n    connection.socket.on(\"close\", drop);\n    connection.socket.on(\"error\", drop);\n    return true;\n  }\n\n  private async *run(request: OpenAITransportRequest): AsyncGenerator<OpenAINormalizedEvent> {\n    let refreshed = false;\n    while (true) {\n      if (request.signal?.aborted) throw abortError(request.signal);\n      const hasAffinity = request.body.prompt_cache_key !== undefined;\n      const retainConnection = hasAffinity && !this.busyAffinities.has(request.threadId);\n      if (retainConnection) this.busyAffinities.add(request.threadId);\n      const entry = retainConnection ? this.affinityConnections.get(request.threadId) : undefined;\n      if (entry?.closed) {\n        this.affinityConnections.delete(request.threadId);\n        entry.events.cleanup();\n      }\n      const cached = entry?.closed ? undefined : entry;\n      // 캐시 등록에 실패하면 이 요청은 재사용 대상이 아니다.\n      let retained = retainConnection;\n      const socket =\n        cached?.socket ??\n        this.webSocketFactory(websocketUrl(CHATGPT_CODEX_RESPONSES_URL), {\n          headers: {\n            ...buildCodexIdentityHeaders(this.credentials.accessToken, this.credentials.accountId, {\n              sessionId: request.sessionId,\n              threadId: request.threadId,\n              clientRequestId: request.clientRequestId,\n            }),\n            \"OpenAI-Beta\": \"responses_websockets=2026-02-06\",\n          },\n        });\n      const events = cached?.events ?? socketEvents(socket, request.signal);\n      let completed = false;\n      try {\n        if (!cached) {\n          const handshake = await events.next();\n          if (\n            handshake.kind === \"rejected\" &&\n            handshake.status === 401 &&\n            !refreshed &&\n            this.refreshCredentials\n          ) {\n            socket.terminate();\n            this.credentials = await this.refreshCredentials();\n            refreshed = true;\n            continue;\n          }\n          if (handshake.kind === \"rejected\") {\n            throw new OpenAIProtocolError(\n              `OpenAI WebSocket handshake rejected${handshake.status ? ` with HTTP ${handshake.status}` : \"\"}`,\n              undefined,\n              handshake.status,\n            );\n          }\n          if (handshake.kind === \"error\") throw handshake.error;\n          if (handshake.kind !== \"open\") {\n            throw new OpenAIProtocolError(\"OpenAI WebSocket closed before the handshake completed\");\n          }\n          if (retainConnection) {\n            retained = this.rememberAffinityConnection(request.threadId, { socket, events });\n          }\n        }\n\n        await new Promise<void>((resolve, reject) => {\n          socket.send(JSON.stringify({ type: \"response.create\", ...request.body }), (error) =>\n            error ? reject(error) : resolve(),\n          );\n        });\n\n        while (true) {\n          const record = cached\n            ? await nextPooledRecord(events, socket, request.signal)\n            : await events.next();\n          if (record.kind === \"message\") {\n            if (record.isBinary) {\n              throw new OpenAIProtocolError(\"OpenAI WebSocket sent an unexpected binary message\");\n            }\n            let raw: unknown;\n            try {\n              raw = JSON.parse(rawDataText(record.data));\n            } catch {\n              throw new OpenAIProtocolError(\"OpenAI WebSocket sent invalid JSON\");\n            }\n            const event = normalizeOpenAIEvent(raw);\n            if (!event) continue;\n            if (event.type === \"completed\") {\n              completed = true;\n              if (retained) events.detachAbort();\n              else socket.close(1000, \"response completed\");\n              yield event;\n              return;\n            }\n            yield event;\n            if (event.type === \"error\") throw event.error;\n          } else if (record.kind === \"error\") {\n            throw record.error;\n          } else if (record.kind === \"close\") {\n            throw new OpenAIProtocolError(\n              `OpenAI WebSocket closed before a terminal response event (${record.code}${record.reason ? `: ${record.reason}` : \"\"})`,\n            );\n          } else {\n            throw new OpenAIProtocolError(\"OpenAI WebSocket emitted an unexpected handshake event\");\n          }\n        }\n      } finally {\n        if (!completed || !retained) {\n          if (retained) this.affinityConnections.delete(request.threadId);\n          events.cleanup();\n          if (!completed) socket.terminate();\n        }\n        if (retainConnection) this.busyAffinities.delete(request.threadId);\n      }\n    }\n  }\n}\n\nasync function responseError(response: Response): Promise<OpenAIProtocolError> {\n  const text = await response.text().catch(() => \"\");\n  let message = text || response.statusText || `HTTP ${response.status}`;\n  let code: string | undefined;\n  try {\n    const parsed = JSON.parse(text) as {\n      error?: { message?: string; code?: string } | string;\n      message?: string;\n      code?: string;\n    };\n    const error = parsed.error;\n    message =\n      (typeof error === \"object\" ? error.message : undefined) ??\n      parsed.message ??\n      (typeof error === \"string\" ? error : message);\n    code = (typeof error === \"object\" ? error.code : undefined) ?? parsed.code;\n  } catch {\n    code = undefined;\n  }\n  return new OpenAIProtocolError(message, code, response.status);\n}\n\nexport class OpenAIHttpsTransport implements OpenAIResponsesTransport {\n  private credentials: OpenAIDirectCredentials;\n  private readonly fetchImpl: typeof fetch;\n  private readonly refreshCredentials?: () => Promise<OpenAIDirectCredentials>;\n\n  constructor(options: OpenAIHttpsTransportOptions) {\n    this.credentials = options.credentials;\n    this.fetchImpl = options.fetch ?? fetch;\n    this.refreshCredentials = options.refreshCredentials;\n  }\n\n  stream(request: OpenAITransportRequest): OpenAIEventStream {\n    return this.run(request);\n  }\n\n  private async *run(request: OpenAITransportRequest): AsyncGenerator<OpenAINormalizedEvent> {\n    let refreshed = false;\n\n    while (true) {\n      const response = await this.fetchImpl(CHATGPT_CODEX_RESPONSES_URL, {\n        method: \"POST\",\n        headers: buildCodexIdentityHeaders(\n          this.credentials.accessToken,\n          this.credentials.accountId,\n          {\n            sessionId: request.sessionId,\n            threadId: request.threadId,\n            clientRequestId: request.clientRequestId,\n          },\n        ),\n        body: JSON.stringify(request.body),\n        signal: request.signal,\n      });\n\n      if (response.status === 401 && !refreshed && this.refreshCredentials) {\n        await response.body?.cancel();\n        this.credentials = await this.refreshCredentials();\n        refreshed = true;\n        continue;\n      }\n      if (!response.ok) throw await responseError(response);\n      if (!response.body) throw new OpenAIProtocolError(\"OpenAI response had no body\");\n\n      for await (const event of normalizeOpenAISSE(response.body)) {\n        yield event;\n      }\n      return;\n    }\n  }\n}\n\nexport interface OpenAIDirectClientOptions extends OpenAIHttpsTransportOptions {\n  transport?: OpenAIResponsesTransport;\n  transportKind?: \"https\" | \"websocket\";\n  webSocketFactory?: OpenAIWebSocketFactory;\n}\n\nexport class OpenAIDirectClient {\n  private readonly transport: OpenAIResponsesTransport;\n\n  constructor(options: OpenAIDirectClientOptions) {\n    this.transport =\n      options.transport ??\n      (options.transportKind === \"websocket\"\n        ? new OpenAIWebSocketTransport(options)\n        : new OpenAIHttpsTransport(options));\n  }\n\n  responses(options: OpenAIResponsesOptions, signal?: AbortSignal): OpenAIEventStream {\n    const clientRequestId = crypto.randomUUID();\n    const affinityId = options.promptCacheKey\n      ? cacheAffinityUuid(options.promptCacheKey)\n      : clientRequestId;\n    return this.transport.stream({\n      body: buildOpenAIResponsesRequest(\n        options.promptCacheKey ? { ...options, promptCacheKey: affinityId } : options,\n      ),\n      signal,\n      sessionId: affinityId,\n      // promptCacheKey is already a one-way SDK affinity value, never a raw sessionKey.\n      threadId: affinityId,\n      clientRequestId,\n    });\n  }\n\n  close(): void {\n    this.transport.close?.();\n  }\n}\n"],"mappings":"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"}