@cartanova/qgrid-cli 2.10.10 → 2.11.0

package/bundle/dist/utils/providers/grok/grok-voice-client.js

@@ -0,0 +1,199 @@
+import "./grok-constants.js";
+import { classifyGrokHttpError, readGrokResponseHeaders } from "./grok-backend-protocol.js";
+import { GrokHttpError, grokHttpErrorFromResponse } from "./grok-direct-client.js";
+import { buildGrokVoiceHeaders } from "./grok-headers.js";
+import { GrokSttResponse, GrokTtsRequest } from "./grok-types.js";
+import { z } from "zod";
+//#region src/utils/providers/grok/grok-voice-client.ts
+const GROK_VOICE_TIMEOUT_MS = 12e4;
+const GROK_TTS_DEFAULT_VOICE = "ara";
+const GROK_TTS_DEFAULT_LANGUAGE = "en";
+const GROK_TTS_DEFAULT_FORMAT = "mp3";
+const CONNECT_FAILURE_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const EXTENSION_BY_SUBTYPE = /* @__PURE__ */ new Map([
+	["mpeg", "mp3"],
+	["x-wav", "wav"],
+	["opus", "ogg"],
+	["mp4", "m4a"],
+	["x-m4a", "m4a"]
+]);
+const MEDIA_TYPE_BY_FORMAT = /* @__PURE__ */ new Map([
+	["mp3", "audio/mpeg"],
+	["wav", "audio/wav"],
+	["pcm", "audio/pcm"],
+	["mulaw", "audio/basic"],
+	["alaw", "audio/x-alaw-basic"]
+]);
+const errorChainLink = z.looseObject({
+	code: z.unknown().optional(),
+	errors: z.unknown().optional(),
+	cause: z.unknown().optional()
+});
+const coded = z.looseObject({ code: z.string() });
+function errorCodes(cause) {
+	const codes = [];
+	let link = errorChainLink.safeParse(cause);
+	for (let depth = 0; depth < 5 && link.success; depth++) {
+		const code = z.string().safeParse(link.data.code);
+		if (code.success) codes.push(code.data);
+		const nested = z.array(z.unknown()).safeParse(link.data.errors);
+		if (nested.success) for (const inner of nested.data) {
+			const innerCode = coded.safeParse(inner);
+			if (innerCode.success) codes.push(innerCode.data.code);
+		}
+		link = errorChainLink.safeParse(link.data.cause);
+	}
+	return codes;
+}
+function isConnectFailure(cause) {
+	const codes = errorCodes(cause);
+	return codes.length > 0 && codes.every((code) => CONNECT_FAILURE_CODES.has(code));
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : new DOMException("Aborted", "AbortError");
+}
+/**
+* Status-0 transient error. `afterSend` failures carry `shouldRetry: false` so no layer replays a
+* POST whose body may have been executed upstream.
+*/
+function transportError(message, afterSend, cause) {
+	const classification = {
+		...classifyGrokHttpError(0, "", {}),
+		message
+	};
+	if (afterSend) classification.shouldRetry = false;
+	return new GrokHttpError(classification, "", {}, { cause });
+}
+function invalidBodyError(response, message, cause) {
+	return new GrokHttpError({
+		...classifyGrokHttpError(502, "", response.headers),
+		message,
+		shouldRetry: false
+	}, "", readGrokResponseHeaders(response.headers), cause === void 0 ? void 0 : { cause });
+}
+function audioExtension(mediaType) {
+	const subtype = mediaType.toLowerCase().split(";")[0]?.split("/")[1]?.trim() ?? "";
+	return EXTENSION_BY_SUBTYPE.get(subtype) ?? (/^[a-z0-9.+-]+$/.test(subtype) ? subtype : "bin");
+}
+function contentMediaType(response) {
+	const value = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+	return value ? value : void 0;
+}
+var GrokVoiceClient = class {
+	fetchImpl;
+	baseUrl;
+	timeoutMs;
+	platform;
+	constructor(options = {}) {
+		this.fetchImpl = options.fetch ?? fetch;
+		this.baseUrl = options.baseUrl ?? "https://api.x.ai/v1";
+		this.timeoutMs = options.timeoutMs ?? 12e4;
+		this.platform = options.platform;
+	}
+	/** Multipart `POST /stt`: `model` first, optional `language`, `file` last (xAI requirement). */
+	async transcribe(bearer, request) {
+		if (request.audio.byteLength === 0) throw new TypeError("audio must not be empty");
+		if (!/^[\w.+-]+\/[\w.+-]+/.test(request.mediaType)) throw new TypeError("mediaType must be a type/subtype media type");
+		const form = new FormData();
+		form.append("model", request.model ?? "grok-voice-transcribe-2.0");
+		if (request.language) form.append("language", request.language);
+		const filename = `audio.${audioExtension(request.mediaType)}`;
+		form.append("file", new File([new Uint8Array(request.audio)], filename, { type: request.mediaType }), filename);
+		const headers = buildGrokVoiceHeaders({
+			bearer,
+			platform: this.platform
+		});
+		return this.post("/stt", headers, form, request.signal, async (response) => {
+			let json;
+			try {
+				json = await response.json();
+			} catch (error) {
+				throw invalidBodyError(response, "invalid JSON body", error);
+			}
+			const record = z.looseObject({}).safeParse(json);
+			const normalized = record.success ? Object.fromEntries(Object.entries(record.data).filter(([, value]) => value !== null)) : json;
+			const parsed = GrokSttResponse.safeParse(normalized);
+			if (!parsed.success) throw invalidBodyError(response, "invalid STT response", parsed.error);
+			const { language, ...rest } = parsed.data;
+			return language ? {
+				...rest,
+				language
+			} : rest;
+		});
+	}
+	/** JSON `POST /tts` returning the raw audio bytes. `language` is required upstream (U0). */
+	async speak(bearer, request) {
+		const body = GrokTtsRequest.parse({
+			text: request.text,
+			voice: request.voice ?? "ara",
+			language: request.language ?? "en",
+			format: request.format ?? "mp3"
+		});
+		const headers = {
+			...buildGrokVoiceHeaders({
+				bearer,
+				platform: this.platform
+			}),
+			"content-type": "application/json"
+		};
+		return this.post("/tts", headers, JSON.stringify(body), request.signal, async (response) => {
+			const mediaType = contentMediaType(response);
+			if (mediaType === "application/json" || mediaType?.startsWith("text/")) throw invalidBodyError(response, `expected audio, got ${mediaType}`);
+			let audio;
+			try {
+				audio = new Uint8Array(await response.arrayBuffer());
+			} catch (error) {
+				throw invalidBodyError(response, "failed to read audio body", error);
+			}
+			if (audio.byteLength === 0) throw invalidBodyError(response, "empty audio body");
+			return {
+				audio,
+				mediaType: mediaType ?? MEDIA_TYPE_BY_FORMAT.get(body.format) ?? "application/octet-stream"
+			};
+		});
+	}
+	/**
+	* One POST, never retried. The total timeout covers the response body too; a caller abort
+	* rethrows the caller's reason.
+	*/
+	async post(path, headers, body, callerSignal, readBody) {
+		if (callerSignal?.aborted) throw abortReason(callerSignal);
+		const timeout = AbortSignal.timeout(this.timeoutMs);
+		const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;
+		const interrupted = (cause) => {
+			if (callerSignal?.aborted) return abortReason(callerSignal);
+			if (timeout.aborted) return transportError(`timed out after ${this.timeoutMs} ms`, true, cause);
+		};
+		let response;
+		try {
+			response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+				method: "POST",
+				headers,
+				body,
+				signal
+			});
+		} catch (error) {
+			const stop = interrupted(error);
+			if (stop) throw stop;
+			throw transportError(error instanceof Error ? error.message : String(error), !isConnectFailure(error), error);
+		}
+		try {
+			if (!response.ok) throw await grokHttpErrorFromResponse(response);
+			return await readBody(response);
+		} catch (error) {
+			throw interrupted(error) ?? error;
+		}
+	}
+};
+//#endregion
+export { GROK_TTS_DEFAULT_FORMAT, GROK_TTS_DEFAULT_LANGUAGE, GROK_TTS_DEFAULT_VOICE, GROK_VOICE_TIMEOUT_MS, GrokVoiceClient };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-voice-client.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-voice-client.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { classifyGrokHttpError, readGrokResponseHeaders } from \"./grok-backend-protocol\";\nimport { GROK_PUBLIC_API_URL, GROK_STT_DEFAULT_MODEL } from \"./grok-constants\";\nimport { GrokHttpError, grokHttpErrorFromResponse } from \"./grok-direct-client\";\nimport { buildGrokVoiceHeaders, type GrokPlatform } from \"./grok-headers\";\nimport {\n  GrokSttResponse,\n  GrokTtsRequest,\n  type GrokSpeechResult,\n  type GrokTranscribeRequest,\n  type GrokVoicePort,\n} from \"./grok-types\";\n\n// HTTP client for api.x.ai speech-to-text (multipart `POST /stt`) and text-to-speech (JSON\n// `POST /tts`), both accepted with the subscription JWT (U0). grok-build only ships a WebSocket\n// STT client, so there is no grok-build precedent for an HTTP timeout; 120 s total covers\n// upload, server processing and the body download of long audio. Requests are never re-issued:\n// once the body may have been sent, upstream may already be executing (and billing) it.\n\nexport const GROK_VOICE_TIMEOUT_MS = 120_000;\nexport const GROK_TTS_DEFAULT_VOICE = \"ara\";\nexport const GROK_TTS_DEFAULT_LANGUAGE = \"en\";\nexport const GROK_TTS_DEFAULT_FORMAT = \"mp3\";\n\n// Undici / Node error codes that prove no connection existed, so no request byte left qgrid.\nconst CONNECT_FAILURE_CODES = new Set([\n  \"ECONNREFUSED\",\n  \"ENOTFOUND\",\n  \"EAI_AGAIN\",\n  \"EHOSTUNREACH\",\n  \"ENETUNREACH\",\n  \"UND_ERR_CONNECT_TIMEOUT\",\n]);\n\n// Same subtype mapping as @ai-sdk/provider-utils mediaTypeToExtension.\nconst EXTENSION_BY_SUBTYPE: ReadonlyMap<string, string> = new Map([\n  [\"mpeg\", \"mp3\"],\n  [\"x-wav\", \"wav\"],\n  [\"opus\", \"ogg\"],\n  [\"mp4\", \"m4a\"],\n  [\"x-m4a\", \"m4a\"],\n]);\n\nconst MEDIA_TYPE_BY_FORMAT: ReadonlyMap<string, string> = new Map([\n  [\"mp3\", \"audio/mpeg\"],\n  [\"wav\", \"audio/wav\"],\n  [\"pcm\", \"audio/pcm\"],\n  [\"mulaw\", \"audio/basic\"],\n  [\"alaw\", \"audio/x-alaw-basic\"],\n]);\n\nexport interface GrokVoiceClientOptions {\n  fetch?: typeof fetch;\n  baseUrl?: string;\n  timeoutMs?: number;\n  platform?: GrokPlatform;\n}\n\n/** `speak` input: the port's request with `voice`, `language` and `format` defaulted. */\nexport type GrokSpeakInput = Pick<GrokTtsRequest, \"text\"> &\n  Partial<Omit<GrokTtsRequest, \"text\">> & { signal?: AbortSignal };\n\n// One link of a thrown value's cause chain; any non-null object qualifies.\nconst errorChainLink = z.looseObject({\n  code: z.unknown().optional(),\n  errors: z.unknown().optional(),\n  cause: z.unknown().optional(),\n});\n\nconst coded = z.looseObject({ code: z.string() });\n\nfunction errorCodes(cause: unknown): string[] {\n  const codes: string[] = [];\n  let link = errorChainLink.safeParse(cause);\n\n  for (let depth = 0; depth < 5 && link.success; depth++) {\n    const code = z.string().safeParse(link.data.code);\n\n    if (code.success) codes.push(code.data);\n    const nested = z.array(z.unknown()).safeParse(link.data.errors);\n\n    if (nested.success) {\n      for (const inner of nested.data) {\n        const innerCode = coded.safeParse(inner);\n\n        if (innerCode.success) codes.push(innerCode.data.code);\n      }\n    }\n\n    link = errorChainLink.safeParse(link.data.cause);\n  }\n\n  return codes;\n}\n\nfunction isConnectFailure(cause: unknown): boolean {\n  const codes = errorCodes(cause);\n\n  return codes.length > 0 && codes.every((code) => CONNECT_FAILURE_CODES.has(code));\n}\n\nfunction abortReason(signal: AbortSignal): Error {\n  const reason: unknown = signal.reason;\n\n  return reason instanceof Error ? reason : new DOMException(\"Aborted\", \"AbortError\");\n}\n\n/**\n * Status-0 transient error. `afterSend` failures carry `shouldRetry: false` so no layer replays a\n * POST whose body may have been executed upstream.\n */\nfunction transportError(message: string, afterSend: boolean, cause: unknown): GrokHttpError {\n  const classification = { ...classifyGrokHttpError(0, \"\", {}), message };\n\n  if (afterSend) classification.shouldRetry = false;\n\n  return new GrokHttpError(classification, \"\", {}, { cause });\n}\n\nfunction invalidBodyError(response: Response, message: string, cause?: unknown): GrokHttpError {\n  return new GrokHttpError(\n    { ...classifyGrokHttpError(502, \"\", response.headers), message, shouldRetry: false },\n    \"\",\n    readGrokResponseHeaders(response.headers),\n    cause === undefined ? undefined : { cause },\n  );\n}\n\nfunction audioExtension(mediaType: string): string {\n  const subtype = mediaType.toLowerCase().split(\";\")[0]?.split(\"/\")[1]?.trim() ?? \"\";\n\n  return EXTENSION_BY_SUBTYPE.get(subtype) ?? (/^[a-z0-9.+-]+$/.test(subtype) ? subtype : \"bin\");\n}\n\nfunction contentMediaType(response: Response): string | undefined {\n  const value = response.headers.get(\"content-type\")?.split(\";\")[0]?.trim().toLowerCase();\n\n  return value ? value : undefined;\n}\n\nexport class GrokVoiceClient implements GrokVoicePort {\n  private readonly fetchImpl: typeof fetch;\n  private readonly baseUrl: string;\n  private readonly timeoutMs: number;\n  private readonly platform: GrokPlatform | undefined;\n\n  constructor(options: GrokVoiceClientOptions = {}) {\n    this.fetchImpl = options.fetch ?? fetch;\n    this.baseUrl = options.baseUrl ?? GROK_PUBLIC_API_URL;\n    this.timeoutMs = options.timeoutMs ?? GROK_VOICE_TIMEOUT_MS;\n    this.platform = options.platform;\n  }\n\n  /** Multipart `POST /stt`: `model` first, optional `language`, `file` last (xAI requirement). */\n  async transcribe(bearer: string, request: GrokTranscribeRequest): Promise<GrokSttResponse> {\n    if (request.audio.byteLength === 0) throw new TypeError(\"audio must not be empty\");\n\n    if (!/^[\\w.+-]+\\/[\\w.+-]+/.test(request.mediaType))\n      throw new TypeError(\"mediaType must be a type/subtype media type\");\n    const form = new FormData();\n    form.append(\"model\", request.model ?? GROK_STT_DEFAULT_MODEL);\n\n    if (request.language) form.append(\"language\", request.language);\n    const filename = `audio.${audioExtension(request.mediaType)}`;\n    form.append(\n      \"file\",\n      new File([new Uint8Array(request.audio)], filename, { type: request.mediaType }),\n      filename,\n    );\n    // fetch sets the multipart content-type with its boundary.\n    const headers = buildGrokVoiceHeaders({ bearer, platform: this.platform });\n\n    return this.post(\"/stt\", headers, form, request.signal, async (response) => {\n      let json: unknown;\n\n      try {\n        json = await response.json();\n      } catch (error) {\n        throw invalidBodyError(response, \"invalid JSON body\", error);\n      }\n\n      // The SDK schema allows null language/duration; treat null as absent.\n      const record = z.looseObject({}).safeParse(json);\n\n      const normalized = record.success\n        ? Object.fromEntries(Object.entries(record.data).filter(([, value]) => value !== null))\n        : json;\n\n      const parsed = GrokSttResponse.safeParse(normalized);\n\n      if (!parsed.success) throw invalidBodyError(response, \"invalid STT response\", parsed.error);\n      const { language, ...rest } = parsed.data;\n\n      return language ? { ...rest, language } : rest;\n    });\n  }\n\n  /** JSON `POST /tts` returning the raw audio bytes. `language` is required upstream (U0). */\n  async speak(bearer: string, request: GrokSpeakInput): Promise<GrokSpeechResult> {\n    const body = GrokTtsRequest.parse({\n      text: request.text,\n      voice: request.voice ?? GROK_TTS_DEFAULT_VOICE,\n      language: request.language ?? GROK_TTS_DEFAULT_LANGUAGE,\n      format: request.format ?? GROK_TTS_DEFAULT_FORMAT,\n    });\n\n    const headers = {\n      ...buildGrokVoiceHeaders({ bearer, platform: this.platform }),\n      \"content-type\": \"application/json\",\n    };\n\n    return this.post(\"/tts\", headers, JSON.stringify(body), request.signal, async (response) => {\n      const mediaType = contentMediaType(response);\n\n      if (mediaType === \"application/json\" || mediaType?.startsWith(\"text/\"))\n        throw invalidBodyError(response, `expected audio, got ${mediaType}`);\n      let audio: Uint8Array;\n\n      try {\n        audio = new Uint8Array(await response.arrayBuffer());\n      } catch (error) {\n        throw invalidBodyError(response, \"failed to read audio body\", error);\n      }\n\n      if (audio.byteLength === 0) throw invalidBodyError(response, \"empty audio body\");\n\n      return {\n        audio,\n        mediaType: mediaType ?? MEDIA_TYPE_BY_FORMAT.get(body.format) ?? \"application/octet-stream\",\n      };\n    });\n  }\n\n  /**\n   * One POST, never retried. The total timeout covers the response body too; a caller abort\n   * rethrows the caller's reason.\n   */\n  private async post<T>(\n    path: string,\n    headers: Record<string, string>,\n    body: FormData | string,\n    callerSignal: AbortSignal | undefined,\n    readBody: (response: Response) => Promise<T>,\n  ): Promise<T> {\n    if (callerSignal?.aborted) throw abortReason(callerSignal);\n    const timeout = AbortSignal.timeout(this.timeoutMs);\n    const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;\n\n    const interrupted = (cause: unknown): Error | undefined => {\n      if (callerSignal?.aborted) return abortReason(callerSignal);\n\n      if (timeout.aborted)\n        return transportError(`timed out after ${this.timeoutMs} ms`, true, cause);\n\n      return undefined;\n    };\n\n    let response: Response;\n\n    try {\n      response = await this.fetchImpl(`${this.baseUrl}${path}`, {\n        method: \"POST\",\n        headers,\n        body,\n        signal,\n      });\n    } catch (error) {\n      const stop = interrupted(error);\n\n      if (stop) throw stop;\n      const message = error instanceof Error ? error.message : String(error);\n      throw transportError(message, !isConnectFailure(error), error);\n    }\n\n    try {\n      if (!response.ok) throw await grokHttpErrorFromResponse(response);\n\n      return await readBody(response);\n    } catch (error) {\n      throw interrupted(error) ?? error;\n    }\n  }\n}\n"],"mappings":";;;;;;;AAoBA,MAAa,wBAAwB;AACrC,MAAa,yBAAyB;AACtC,MAAa,4BAA4B;AACzC,MAAa,0BAA0B;AAGvC,MAAM,wCAAwB,IAAI,IAAI;CACpC;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAGD,MAAM,uCAAoD,IAAI,IAAI;CAChE,CAAC,QAAQ,KAAK;CACd,CAAC,SAAS,KAAK;CACf,CAAC,QAAQ,KAAK;CACd,CAAC,OAAO,KAAK;CACb,CAAC,SAAS,KAAK;AACjB,CAAC;AAED,MAAM,uCAAoD,IAAI,IAAI;CAChE,CAAC,OAAO,YAAY;CACpB,CAAC,OAAO,WAAW;CACnB,CAAC,OAAO,WAAW;CACnB,CAAC,SAAS,aAAa;CACvB,CAAC,QAAQ,oBAAoB;AAC/B,CAAC;AAcD,MAAM,iBAAiB,EAAE,YAAY;CACnC,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS;CAC3B,QAAQ,EAAE,QAAQ,CAAC,CAAC,SAAS;CAC7B,OAAO,EAAE,QAAQ,CAAC,CAAC,SAAS;AAC9B,CAAC;AAED,MAAM,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AAEhD,SAAS,WAAW,OAA0B;CAC5C,MAAM,QAAkB,CAAC;CACzB,IAAI,OAAO,eAAe,UAAU,KAAK;CAEzC,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,KAAK,SAAS,SAAS;EACtD,MAAM,OAAO,EAAE,OAAO,CAAC,CAAC,UAAU,KAAK,KAAK,IAAI;EAEhD,IAAI,KAAK,SAAS,MAAM,KAAK,KAAK,IAAI;EACtC,MAAM,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,UAAU,KAAK,KAAK,MAAM;EAE9D,IAAI,OAAO,SACT,KAAK,MAAM,SAAS,OAAO,MAAM;GAC/B,MAAM,YAAY,MAAM,UAAU,KAAK;GAEvC,IAAI,UAAU,SAAS,MAAM,KAAK,UAAU,KAAK,IAAI;EACvD;EAGF,OAAO,eAAe,UAAU,KAAK,KAAK,KAAK;CACjD;CAEA,OAAO;AACT;AAEA,SAAS,iBAAiB,OAAyB;CACjD,MAAM,QAAQ,WAAW,KAAK;CAE9B,OAAO,MAAM,SAAS,KAAK,MAAM,OAAO,SAAS,sBAAsB,IAAI,IAAI,CAAC;AAClF;AAEA,SAAS,YAAY,QAA4B;CAC/C,MAAM,SAAkB,OAAO;CAE/B,OAAO,kBAAkB,QAAQ,SAAS,IAAI,aAAa,WAAW,YAAY;AACpF;;;;;AAMA,SAAS,eAAe,SAAiB,WAAoB,OAA+B;CAC1F,MAAM,iBAAiB;EAAE,GAAG,sBAAsB,GAAG,IAAI,CAAC,CAAC;EAAG;CAAQ;CAEtE,IAAI,WAAW,eAAe,cAAc;CAE5C,OAAO,IAAI,cAAc,gBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC;AAC5D;AAEA,SAAS,iBAAiB,UAAoB,SAAiB,OAAgC;CAC7F,OAAO,IAAI,cACT;EAAE,GAAG,sBAAsB,KAAK,IAAI,SAAS,OAAO;EAAG;EAAS,aAAa;CAAM,GACnF,IACA,wBAAwB,SAAS,OAAO,GACxC,UAAU,SAAY,SAAY,EAAE,MAAM,CAC5C;AACF;AAEA,SAAS,eAAe,WAA2B;CACjD,MAAM,UAAU,UAAU,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,KAAK;CAEhF,OAAO,qBAAqB,IAAI,OAAO,MAAM,iBAAiB,KAAK,OAAO,IAAI,UAAU;AAC1F;AAEA,SAAS,iBAAiB,UAAwC;CAChE,MAAM,QAAQ,SAAS,QAAQ,IAAI,cAAc,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,YAAY;CAEtF,OAAO,QAAQ,QAAQ;AACzB;AAEA,IAAa,kBAAb,MAAsD;CACpD;CACA;CACA;CACA;CAEA,YAAY,UAAkC,CAAC,GAAG;EAChD,KAAK,YAAY,QAAQ,SAAS;EAClC,KAAK,UAAU,QAAQ,WAAA;EACvB,KAAK,YAAY,QAAQ,aAAA;EACzB,KAAK,WAAW,QAAQ;CAC1B;;CAGA,MAAM,WAAW,QAAgB,SAA0D;EACzF,IAAI,QAAQ,MAAM,eAAe,GAAG,MAAM,IAAI,UAAU,yBAAyB;EAEjF,IAAI,CAAC,sBAAsB,KAAK,QAAQ,SAAS,GAC/C,MAAM,IAAI,UAAU,6CAA6C;EACnE,MAAM,OAAO,IAAI,SAAS;EAC1B,KAAK,OAAO,SAAS,QAAQ,SAAA,2BAA+B;EAE5D,IAAI,QAAQ,UAAU,KAAK,OAAO,YAAY,QAAQ,QAAQ;EAC9D,MAAM,WAAW,SAAS,eAAe,QAAQ,SAAS;EAC1D,KAAK,OACH,QACA,IAAI,KAAK,CAAC,IAAI,WAAW,QAAQ,KAAK,CAAC,GAAG,UAAU,EAAE,MAAM,QAAQ,UAAU,CAAC,GAC/E,QACF;EAEA,MAAM,UAAU,sBAAsB;GAAE;GAAQ,UAAU,KAAK;EAAS,CAAC;EAEzE,OAAO,KAAK,KAAK,QAAQ,SAAS,MAAM,QAAQ,QAAQ,OAAO,aAAa;GAC1E,IAAI;GAEJ,IAAI;IACF,OAAO,MAAM,SAAS,KAAK;GAC7B,SAAS,OAAO;IACd,MAAM,iBAAiB,UAAU,qBAAqB,KAAK;GAC7D;GAGA,MAAM,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,IAAI;GAE/C,MAAM,aAAa,OAAO,UACtB,OAAO,YAAY,OAAO,QAAQ,OAAO,IAAI,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,IAAI,CAAC,IACpF;GAEJ,MAAM,SAAS,gBAAgB,UAAU,UAAU;GAEnD,IAAI,CAAC,OAAO,SAAS,MAAM,iBAAiB,UAAU,wBAAwB,OAAO,KAAK;GAC1F,MAAM,EAAE,UAAU,GAAG,SAAS,OAAO;GAErC,OAAO,WAAW;IAAE,GAAG;IAAM;GAAS,IAAI;EAC5C,CAAC;CACH;;CAGA,MAAM,MAAM,QAAgB,SAAoD;EAC9E,MAAM,OAAO,eAAe,MAAM;GAChC,MAAM,QAAQ;GACd,OAAO,QAAQ,SAAA;GACf,UAAU,QAAQ,YAAA;GAClB,QAAQ,QAAQ,UAAA;EAClB,CAAC;EAED,MAAM,UAAU;GACd,GAAG,sBAAsB;IAAE;IAAQ,UAAU,KAAK;GAAS,CAAC;GAC5D,gBAAgB;EAClB;EAEA,OAAO,KAAK,KAAK,QAAQ,SAAS,KAAK,UAAU,IAAI,GAAG,QAAQ,QAAQ,OAAO,aAAa;GAC1F,MAAM,YAAY,iBAAiB,QAAQ;GAE3C,IAAI,cAAc,sBAAsB,WAAW,WAAW,OAAO,GACnE,MAAM,iBAAiB,UAAU,uBAAuB,WAAW;GACrE,IAAI;GAEJ,IAAI;IACF,QAAQ,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC;GACrD,SAAS,OAAO;IACd,MAAM,iBAAiB,UAAU,6BAA6B,KAAK;GACrE;GAEA,IAAI,MAAM,eAAe,GAAG,MAAM,iBAAiB,UAAU,kBAAkB;GAE/E,OAAO;IACL;IACA,WAAW,aAAa,qBAAqB,IAAI,KAAK,MAAM,KAAK;GACnE;EACF,CAAC;CACH;;;;;CAMA,MAAc,KACZ,MACA,SACA,MACA,cACA,UACY;EACZ,IAAI,cAAc,SAAS,MAAM,YAAY,YAAY;EACzD,MAAM,UAAU,YAAY,QAAQ,KAAK,SAAS;EAClD,MAAM,SAAS,eAAe,YAAY,IAAI,CAAC,cAAc,OAAO,CAAC,IAAI;EAEzE,MAAM,eAAe,UAAsC;GACzD,IAAI,cAAc,SAAS,OAAO,YAAY,YAAY;GAE1D,IAAI,QAAQ,SACV,OAAO,eAAe,mBAAmB,KAAK,UAAU,MAAM,MAAM,KAAK;EAG7E;EAEA,IAAI;EAEJ,IAAI;GACF,WAAW,MAAM,KAAK,UAAU,GAAG,KAAK,UAAU,QAAQ;IACxD,QAAQ;IACR;IACA;IACA;GACF,CAAC;EACH,SAAS,OAAO;GACd,MAAM,OAAO,YAAY,KAAK;GAE9B,IAAI,MAAM,MAAM;GAEhB,MAAM,eADU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GACvC,CAAC,iBAAiB,KAAK,GAAG,KAAK;EAC/D;EAEA,IAAI;GACF,IAAI,CAAC,SAAS,IAAI,MAAM,MAAM,0BAA0B,QAAQ;GAEhE,OAAO,MAAM,SAAS,QAAQ;EAChC,SAAS,OAAO;GACd,MAAM,YAAY,KAAK,KAAK;EAC9B;CACF;AACF"}

package/bundle/dist/utils/providers/grok/index.js

@@ -0,0 +1,11 @@
+import { GROK_AUTH_ISSUER, GROK_BUILD_COMMIT, GROK_BUILD_VERSION, GROK_CHAT_PROXY_URL, GROK_CLIENT_IDENTIFIER, GROK_CLIENT_MODE, GROK_COMPACTIONS_REMAINING_DEFAULT, GROK_COMPACTION_AT, GROK_DEFAULT_MODEL, GROK_DEVICE_CODE_URL, GROK_DEVICE_TOKEN_URL, GROK_DOOM_LOOP_CHECK, GROK_EXACT_REPETITION_CHECK, GROK_IMAGE_DEFAULT_MODEL, GROK_MIN_CLIENT_VERSION_OBSERVED, GROK_OAUTH_CLIENT_ID, GROK_OAUTH_REFERRER, GROK_OAUTH_SCOPES, GROK_PUBLIC_API_URL, GROK_REASONING_EFFORTS, GROK_SEED_MODELS, GROK_STT_DEFAULT_MODEL, GROK_USD_PER_TICK, GROK_VIDEO_DEFAULT_MODEL } from "./grok-constants.js";
+import { GROK_DEFAULT_OUTPUT_SCHEMA_NAME, GrokProtocolError, buildGrokResponsesRequest, classifyGrokHttpError, encodeGrokRequestBody, encodeGrokRequestBodyPlain, grokUsageFrom, normalizeGrokEvent, normalizeGrokSSE, parseGrokSSE, parseRetryAfterSec, parseShouldRetry, readGrokResponseHeaders } from "./grok-backend-protocol.js";
+import { GROK_DEFAULT_IDLE_TIMEOUT_MS, GROK_PROXY_GET_TIMEOUT_MS, GrokChatClient, GrokHttpError, GrokIdleTimeoutError, grokHttpErrorFromResponse, grokProxyGet } from "./grok-direct-client.js";
+import { buildGrokChatHeaders, buildGrokMediaHeaders, buildGrokProxyGetHeaders, buildGrokVoiceHeaders, generateTraceparent, grokMediaUserAgent, grokPlatform, grokShellUserAgent } from "./grok-headers.js";
+import { GrokApiImageModel, GrokApiImageModelCatalog, GrokApiLanguageModel, GrokApiLanguageModelCatalog, GrokBillingConfig, GrokCredentials, GrokImageResponse, GrokModelReasoningEffort, GrokModelsResponse, GrokProxyModel, GrokSettings, GrokSttResponse, GrokTtsRequest, GrokUserSubscription, GrokVideoStart, GrokVideoStatus, decodeGrokJwt, grokCatalogModels, grokVideoUrl, isGrokAccessToken } from "./grok-types.js";
+import { GrokModelCatalog, canonicalGrokModelId } from "./grok-models.js";
+import { readGrokBilling, readGrokSettings, readGrokSubscription } from "./grok-quota.js";
+import { GROK_DEVICE_DEFAULT_INTERVAL_S, GROK_DEVICE_SLOW_DOWN_INCREMENT_S, GROK_DISCOVERY_TTL_MS, GROK_FALLBACK_AUTHORIZATION_ENDPOINT, GROK_FALLBACK_TOKEN_ENDPOINT, GROK_OAUTH_SCOPE, GrokOAuthError, GrokTokenResponse, buildGrokAuthorizeUrl, completeGrokOAuth, finishGrokLogin, generateGrokPkce, getGrokOAuthEndpoints, grokLoopbackRedirectUri, parseGrokCallbackInput, pollGrokDeviceCode, readGrokOAuthErrorCode, resetGrokDiscoveryCache, startGrokDeviceCode, startGrokOAuth } from "./grok-oauth.js";
+import { GROK_REFRESH_JITTER_MAX_MS, GROK_REFRESH_MARGIN_MS, GrokReauthRequiredError, GrokRefreshCoordinator, GrokRefreshTransientError, grokNeedsRefresh, grokRefreshJitterMs } from "./grok-refresh.js";
+import { GROK_DEFAULT_COOLDOWN_MS, GROK_ENTITLEMENT_BLOCK_MS, GROK_LOOKUP_CACHE_TTL_MS, GROK_MAX_COOLDOWN_MS, GROK_MAX_COOLDOWN_WAIT_MS, GROK_MAX_HOPS, GROK_MAX_REFRESHES, GROK_MAX_STALE_AUTH_RETRIES, GROK_MAX_TRANSIENT_FAILOVERS, GROK_QUOTA_BLOCK_FALLBACK_MS, GROK_REFRESH_FAILED_COOLDOWN_MS, GROK_VERSION_GATE_REPROBE_MS, GrokAttemptBudgetExceededError, GrokCapabilityUnavailableError, GrokCapacityError, GrokCredentialRefreshError, GrokDispatcher, GrokIncompleteResponseError, GrokInvalidRequestError, GrokNoWorkersError, GrokOnDemandExcludedError, GrokRateLimitedError, GrokVersionGateError, GrokZdrVideoUnavailableError, grokConversationIds, grokTicksToUsd, isGrokZdrVideoRejection } from "./grok-dispatcher.js";
+export { GROK_AUTH_ISSUER, GROK_BUILD_COMMIT, GROK_BUILD_VERSION, GROK_CHAT_PROXY_URL, GROK_CLIENT_IDENTIFIER, GROK_CLIENT_MODE, GROK_COMPACTIONS_REMAINING_DEFAULT, GROK_COMPACTION_AT, GROK_DEFAULT_COOLDOWN_MS, GROK_DEFAULT_IDLE_TIMEOUT_MS, GROK_DEFAULT_MODEL, GROK_DEFAULT_OUTPUT_SCHEMA_NAME, GROK_DEVICE_CODE_URL, GROK_DEVICE_DEFAULT_INTERVAL_S, GROK_DEVICE_SLOW_DOWN_INCREMENT_S, GROK_DEVICE_TOKEN_URL, GROK_DISCOVERY_TTL_MS, GROK_DOOM_LOOP_CHECK, GROK_ENTITLEMENT_BLOCK_MS, GROK_EXACT_REPETITION_CHECK, GROK_FALLBACK_AUTHORIZATION_ENDPOINT, GROK_FALLBACK_TOKEN_ENDPOINT, GROK_IMAGE_DEFAULT_MODEL, GROK_LOOKUP_CACHE_TTL_MS, GROK_MAX_COOLDOWN_MS, GROK_MAX_COOLDOWN_WAIT_MS, GROK_MAX_HOPS, GROK_MAX_REFRESHES, GROK_MAX_STALE_AUTH_RETRIES, GROK_MAX_TRANSIENT_FAILOVERS, GROK_MIN_CLIENT_VERSION_OBSERVED, GROK_OAUTH_CLIENT_ID, GROK_OAUTH_REFERRER, GROK_OAUTH_SCOPE, GROK_OAUTH_SCOPES, GROK_PROXY_GET_TIMEOUT_MS, GROK_PUBLIC_API_URL, GROK_QUOTA_BLOCK_FALLBACK_MS, GROK_REASONING_EFFORTS, GROK_REFRESH_FAILED_COOLDOWN_MS, GROK_REFRESH_JITTER_MAX_MS, GROK_REFRESH_MARGIN_MS, GROK_SEED_MODELS, GROK_STT_DEFAULT_MODEL, GROK_USD_PER_TICK, GROK_VERSION_GATE_REPROBE_MS, GROK_VIDEO_DEFAULT_MODEL, GrokApiImageModel, GrokApiImageModelCatalog, GrokApiLanguageModel, GrokApiLanguageModelCatalog, GrokAttemptBudgetExceededError, GrokBillingConfig, GrokCapabilityUnavailableError, GrokCapacityError, GrokChatClient, GrokCredentialRefreshError, GrokCredentials, GrokDispatcher, GrokHttpError, GrokIdleTimeoutError, GrokImageResponse, GrokIncompleteResponseError, GrokInvalidRequestError, GrokModelCatalog, GrokModelReasoningEffort, GrokModelsResponse, GrokNoWorkersError, GrokOAuthError, GrokOnDemandExcludedError, GrokProtocolError, GrokProxyModel, GrokRateLimitedError, GrokReauthRequiredError, GrokRefreshCoordinator, GrokRefreshTransientError, GrokSettings, GrokSttResponse, GrokTokenResponse, GrokTtsRequest, GrokUserSubscription, GrokVersionGateError, GrokVideoStart, GrokVideoStatus, GrokZdrVideoUnavailableError, buildGrokAuthorizeUrl, buildGrokChatHeaders, buildGrokMediaHeaders, buildGrokProxyGetHeaders, buildGrokResponsesRequest, buildGrokVoiceHeaders, canonicalGrokModelId, classifyGrokHttpError, completeGrokOAuth, decodeGrokJwt, encodeGrokRequestBody, encodeGrokRequestBodyPlain, finishGrokLogin, generateGrokPkce, generateTraceparent, getGrokOAuthEndpoints, grokCatalogModels, grokConversationIds, grokHttpErrorFromResponse, grokLoopbackRedirectUri, grokMediaUserAgent, grokNeedsRefresh, grokPlatform, grokProxyGet, grokRefreshJitterMs, grokShellUserAgent, grokTicksToUsd, grokUsageFrom, grokVideoUrl, isGrokAccessToken, isGrokZdrVideoRejection, normalizeGrokEvent, normalizeGrokSSE, parseGrokCallbackInput, parseGrokSSE, parseRetryAfterSec, parseShouldRetry, pollGrokDeviceCode, readGrokBilling, readGrokOAuthErrorCode, readGrokResponseHeaders, readGrokSettings, readGrokSubscription, resetGrokDiscoveryCache, startGrokDeviceCode, startGrokOAuth };

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

@@ -1,4 +1,6 @@
+import { isJsonObject, jsonString } from "../common/provider-types.js";
 import { ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types.js";
+import { z } from "zod";
 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";
@@ -29,43 +31,46 @@ function buildOpenAIResponsesRequest(options) {
 		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 {
+	const request = {
 		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 } : {}
+		include: ["reasoning.encrypted_content"]
 	};
+	if (options.instructions) request.instructions = options.instructions;
+	if (tools.length) request.tools = tools;
+	if (options.serviceTier) request.service_tier = options.serviceTier;
+	if (options.promptCacheKey) request.prompt_cache_key = options.promptCacheKey;
+	if (options.verbosity || options.outputSchema) {
+		const text = {};
+		if (options.verbosity) text.verbosity = options.verbosity;
+		if (options.outputSchema) text.format = {
+			type: "json_schema",
+			strict: true,
+			schema: options.outputSchema.schema,
+			name: options.outputSchema.name ?? "codex_output_schema"
+		};
+		request.text = text;
+	}
+	return request;
 }
 function buildCodexIdentityHeaders(accessToken, accountId, correlation) {
-	return {
+	const headers = {
 		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 } : {}
+		"User-Agent": codexCliUserAgent()
 	};
+	if (correlation?.sessionId) headers["session-id"] = correlation.sessionId;
+	if (correlation?.threadId) headers["thread-id"] = correlation.threadId;
+	if (correlation?.clientRequestId) headers["x-client-request-id"] = correlation.clientRequestId;
+	return headers;
 }
 var OpenAIProtocolError = class extends Error {
 	code;
@@ -79,17 +84,19 @@ var OpenAIProtocolError = class extends Error {
 		this.name = "OpenAIProtocolError";
 	}
 };
+const tokenCount = z.coerce.number().catch(0);
+function jsonObjectOrEmpty(value) {
+	return isJsonObject(value) ? value : {};
+}
 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 ?? {};
+	const inputDetails = jsonObjectOrEmpty(value.input_tokens_details);
+	const outputDetails = jsonObjectOrEmpty(value.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)
+		inputTokens: tokenCount.parse(value.input_tokens ?? 0),
+		cachedInputTokens: tokenCount.parse(inputDetails.cached_tokens ?? 0),
+		outputTokens: tokenCount.parse(value.output_tokens ?? 0),
+		reasoningTokens: tokenCount.parse(outputDetails.reasoning_tokens ?? 0),
+		totalTokens: tokenCount.parse(value.total_tokens ?? 0)
 	};
 }
 function imageMimeType(base64, outputFormat) {
@@ -109,79 +116,100 @@ function imageMimeType(base64, outputFormat) {
 	if (outputFormat === "jpeg") return "image/jpeg";
 	if (outputFormat === "webp") return "image/webp";
 	if (outputFormat === void 0 || outputFormat === "png") return "image/png";
-	throw new OpenAIProtocolError(`Unsupported image output format: ${String(outputFormat)}`);
+	throw new OpenAIProtocolError(`Unsupported image output format: ${jsonString(outputFormat) ?? JSON.stringify(outputFormat)}`);
+}
+function imageEvent(item, result) {
+	const header = Buffer.from(result.slice(0, 32), "base64");
+	const pngSize = header.length >= 24 && header.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")) && header.readUInt32BE(16) > 0 && header.readUInt32BE(20) > 0 ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}` : void 0;
+	const reportedSize = jsonString(item.size);
+	const size = pngSize ?? (reportedSize !== void 0 && /^[1-9]\d*x[1-9]\d*$/.test(reportedSize) ? reportedSize : void 0);
+	const id = jsonString(item.id);
+	const model = jsonString(item.model);
+	const quality = jsonString(item.quality);
+	const background = jsonString(item.background);
+	const revisedPrompt = jsonString(item.revised_prompt) ?? jsonString(item.revisedPrompt);
+	const generation = { route: "codex-responses" };
+	if (size) generation.size = size;
+	if (model !== void 0) generation.model = model;
+	if (quality !== void 0) generation.quality = quality;
+	if (background !== void 0) generation.background = background;
+	const event = {
+		type: "image",
+		base64: result,
+		mimeType: "image/png"
+	};
+	if (id !== void 0) event.id = id;
+	event.base64 = result;
+	event.mimeType = imageMimeType(result, item.output_format);
+	event.generation = generation;
+	if (revisedPrompt !== void 0) event.revisedPrompt = revisedPrompt;
+	return event;
+}
+function completedEvent(response) {
+	const toolUsage = jsonObjectOrEmpty(response.tool_usage);
+	const parsedImageUsage = ImageGenerationMetadata.shape.usage.safeParse(toolUsage.image_gen);
+	const imageUsage = parsedImageUsage.success ? parsedImageUsage.data : void 0;
+	const imageTool = Array.isArray(response.tools) ? response.tools.find((tool) => isJsonObject(tool) && tool.type === "image_generation") : void 0;
+	const imageModel = isJsonObject(imageTool) ? jsonString(imageTool.model) : void 0;
+	const model = jsonString(response.model);
+	const event = {
+		type: "completed",
+		responseId: jsonString(response.id) ?? ""
+	};
+	if (isJsonObject(response.usage)) event.usage = usageFrom(response.usage);
+	if (model !== void 0) event.model = model;
+	if (imageUsage || imageModel) {
+		const imageGeneration = { route: "codex-responses" };
+		if (imageModel) imageGeneration.model = imageModel;
+		if (imageUsage) imageGeneration.usage = imageUsage;
+		event.imageGeneration = imageGeneration;
+	}
+	return event;
 }
 function normalizeOpenAIEvent(raw) {
-	if (!raw || typeof raw !== "object") return void 0;
+	if (!isJsonObject(raw)) return void 0;
 	const event = raw;
-	const type = String(event.type ?? "");
+	const type = jsonString(event.type) ?? "";
 	if (type === "response.created") {
-		const response = event.response;
-		return {
+		const responseId = isJsonObject(event.response) ? jsonString(event.response.id) : void 0;
+		return responseId ? {
 			type: "created",
-			...response?.id ? { responseId: String(response.id) } : {}
+			responseId
+		} : { type: "created" };
+	}
+	const delta = jsonString(event.delta);
+	if (type === "response.output_text.delta" && delta !== void 0) {
+		const itemId = jsonString(event.item_id);
+		return itemId === void 0 ? {
+			type: "text-delta",
+			text: delta
+		} : {
+			type: "text-delta",
+			text: delta,
+			itemId
 		};
 	}
-	if (type === "response.output_text.delta" && typeof event.delta === "string") return {
-		type: "text-delta",
-		text: event.delta,
-		...typeof event.item_id === "string" ? { itemId: event.item_id } : {}
-	};
-	if ((type === "response.output_item.added" || type === "response.output_item.done") && event.item && typeof event.item === "object") {
+	if ((type === "response.output_item.added" || type === "response.output_item.done") && isJsonObject(event.item)) {
 		const item = event.item;
-		if (item.type === "image_generation_call" && typeof item.result === "string") {
-			const header = Buffer.from(item.result.slice(0, 32), "base64");
-			const size = (header.length >= 24 && header.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")) && header.readUInt32BE(16) > 0 && header.readUInt32BE(20) > 0 ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}` : void 0) ?? (typeof item.size === "string" && /^[1-9]\d*x[1-9]\d*$/.test(item.size) ? item.size : void 0);
-			return {
-				type: "image",
-				...typeof item.id === "string" ? { id: item.id } : {},
-				base64: item.result,
-				mimeType: imageMimeType(item.result, item.output_format),
-				generation: {
-					route: "codex-responses",
-					...size ? { size } : {},
-					...typeof item.model === "string" ? { model: item.model } : {},
-					...typeof item.quality === "string" ? { quality: item.quality } : {},
-					...typeof item.background === "string" ? { background: item.background } : {}
-				},
-				...typeof item.revised_prompt === "string" ? { revisedPrompt: item.revised_prompt } : typeof item.revisedPrompt === "string" ? { revisedPrompt: item.revisedPrompt } : {}
-			};
-		}
+		const result = jsonString(item.result);
+		if (item.type === "image_generation_call" && result !== void 0) return imageEvent(item, result);
 		return {
 			type: "output-item",
 			item,
 			completed: type === "response.output_item.done"
 		};
 	}
-	if (type === "response.completed") {
-		const response = event.response ?? {};
-		const toolUsage = response.tool_usage;
-		const parsedImageUsage = ImageGenerationMetadata.shape.usage.safeParse(toolUsage?.image_gen);
-		const imageUsage = parsedImageUsage.success ? parsedImageUsage.data : void 0;
-		const imageTool = Array.isArray(response.tools) ? response.tools.find((tool) => tool?.type === "image_generation") : void 0;
-		const imageModel = typeof imageTool?.model === "string" ? imageTool.model : void 0;
-		return {
-			type: "completed",
-			responseId: String(response.id ?? ""),
-			...response.usage ? { usage: usageFrom(response.usage) } : {},
-			...typeof response.model === "string" ? { model: response.model } : {},
-			...imageUsage || imageModel ? { imageGeneration: {
-				route: "codex-responses",
-				...imageModel ? { model: imageModel } : {},
-				...imageUsage ? { usage: imageUsage } : {}
-			} } : {}
-		};
-	}
+	if (type === "response.completed") return completedEvent(jsonObjectOrEmpty(event.response));
 	if (type === "error" || type === "response.failed" || type === "response.incomplete") {
-		const source = event.error ?? event.response ?? event;
-		const nested = source.error ?? source;
+		const source = jsonObjectOrEmpty(event.error ?? event.response ?? event);
+		const nested = jsonObjectOrEmpty(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)
+			error: new OpenAIProtocolError(jsonString(nested.message) ?? `OpenAI stream ended with ${type}`, jsonString(nested.code))
 		};
 	}
 }
 //#endregion
 export { CHATGPT_CODEX_RESPONSES_URL, CODEX_CLI_ORIGINATOR, CODEX_CLI_VERSION, OpenAIProtocolError, buildCodexIdentityHeaders, buildOpenAIResponsesRequest, codexCliUserAgent, imageMimeType, 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\nimport { ImageGenerationMetadata } from \"../../../application/qgrid/qgrid.types\";\nimport { type OpenAIEffort } from \"../common/effort\";\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?: OpenAIEffort | \"none\";\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; itemId?: string }\n  | {\n      type: \"image\";\n      id?: string;\n      base64: string;\n      mimeType: \"image/png\" | \"image/jpeg\" | \"image/webp\";\n      revisedPrompt?: string;\n      generation?: ImageGenerationMetadata;\n    }\n  | { type: \"output-item\"; item: OpenAIResponseItem; completed?: boolean }\n  | {\n      type: \"completed\";\n      responseId: string;\n      usage?: OpenAIUsage;\n      model?: string;\n      imageGeneration?: ImageGenerationMetadata;\n    }\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 imageMimeType(\n  base64: string,\n  outputFormat?: unknown,\n): \"image/png\" | \"image/jpeg\" | \"image/webp\" {\n  // Inspect only the header, without decoding a potentially large image twice.\n  const header = Buffer.from(base64.slice(0, 24), \"base64\");\n  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))\n    return \"image/png\";\n  if (header[0] === 255 && header[1] === 216 && header[2] === 255) return \"image/jpeg\";\n  if (header.toString(\"ascii\", 0, 4) === \"RIFF\" && header.toString(\"ascii\", 8, 12) === \"WEBP\")\n    return \"image/webp\";\n  if (outputFormat === \"jpeg\") return \"image/jpeg\";\n  if (outputFormat === \"webp\") return \"image/webp\";\n  if (outputFormat === undefined || outputFormat === \"png\") return \"image/png\";\n  throw new OpenAIProtocolError(`Unsupported image output format: ${String(outputFormat)}`);\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 {\n      type: \"text-delta\",\n      text: event.delta,\n      ...(typeof event.item_id === \"string\" ? { itemId: event.item_id } : {}),\n    };\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      // PNG exposes dimensions in its fixed header. Other formats retain the\n      // backend's observed size; never substitute requested image controls.\n      const header = Buffer.from(item.result.slice(0, 32), \"base64\");\n      const pngSize =\n        header.length >= 24 &&\n        header.subarray(0, 8).equals(Buffer.from(\"89504e470d0a1a0a\", \"hex\")) &&\n        header.readUInt32BE(16) > 0 &&\n        header.readUInt32BE(20) > 0\n          ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}`\n          : undefined;\n      const size =\n        pngSize ??\n        (typeof item.size === \"string\" && /^[1-9]\\d*x[1-9]\\d*$/.test(item.size)\n          ? item.size\n          : undefined);\n      return {\n        type: \"image\",\n        ...(typeof item.id === \"string\" ? { id: item.id } : {}),\n        base64: item.result,\n        mimeType: imageMimeType(item.result, item.output_format),\n        generation: {\n          route: \"codex-responses\",\n          ...(size ? { size } : {}),\n          ...(typeof item.model === \"string\" ? { model: item.model } : {}),\n          ...(typeof item.quality === \"string\" ? { quality: item.quality } : {}),\n          ...(typeof item.background === \"string\" ? { background: item.background } : {}),\n        },\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, completed: type === \"response.output_item.done\" };\n  }\n  if (type === \"response.completed\") {\n    const response = (event.response ?? {}) as Record<string, unknown>;\n    const toolUsage = response.tool_usage as Record<string, unknown> | undefined;\n    const parsedImageUsage = ImageGenerationMetadata.shape.usage.safeParse(toolUsage?.image_gen);\n    const imageUsage = parsedImageUsage.success ? parsedImageUsage.data : undefined;\n    const imageTool = Array.isArray(response.tools)\n      ? response.tools.find((tool) => tool?.type === \"image_generation\")\n      : undefined;\n    const imageModel = typeof imageTool?.model === \"string\" ? imageTool.model : undefined;\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      ...(imageUsage || imageModel\n        ? {\n            imageGeneration: {\n              route: \"codex-responses\" as const,\n              ...(imageModel ? { model: imageModel } : {}),\n              ...(imageUsage ? { usage: imageUsage } : {}),\n            },\n          }\n        : {}),\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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"}
+//# 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\nimport { z } from \"zod\";\n\nimport { ImageGenerationMetadata } from \"../../../application/qgrid/qgrid.types\";\nimport { type OpenAIEffort } from \"../common/effort\";\nimport {\n  isJsonObject,\n  type JsonObject,\n  type JsonValue,\n  jsonString,\n} from \"../common/provider-types\";\n\nexport { type JsonValue } from \"../common/provider-types\";\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\n  const terminal = process.env.TERM_PROGRAM;\n  const terminalVersion = process.env.TERM_PROGRAM_VERSION;\n\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\n/** Raw Responses API items. Keeping these opaque preserves the complete conversation history. */\nexport type OpenAIResponseItem = JsonObject;\n\nexport interface OpenAIOutputSchema {\n  name?: string;\n  schema: JsonValue;\n}\n\nexport interface OpenAIResponsesOptions {\n  model: string;\n  instructions?: string;\n  /** Raw conversation items, forwarded unchanged. */\n  history: readonly JsonValue[];\n  tools?: readonly OpenAIResponseItem[];\n  toolChoice?: string | OpenAIResponseItem;\n  parallelToolCalls?: boolean;\n  reasoning?: {\n    effort?: OpenAIEffort | \"none\";\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: JsonValue[];\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?: OpenAIResponsesText;\n}\n\nexport interface OpenAIResponsesText {\n  verbosity?: \"low\" | \"medium\" | \"high\";\n  format?: {\n    type: \"json_schema\";\n    strict: true;\n    schema: JsonValue;\n    name: string;\n  };\n}\n\nexport function buildOpenAIResponsesRequest(\n  options: OpenAIResponsesOptions,\n): OpenAIResponsesRequest {\n  const tools = options.tools ? [...options.tools] : [];\n\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 request: OpenAIResponsesRequest = {\n    model: options.model,\n    // Copy the array, not its items: raw items must arrive byte-for-byte equivalent.\n    input: [...options.history],\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  };\n\n  if (options.instructions) request.instructions = options.instructions;\n\n  if (tools.length) request.tools = tools;\n\n  if (options.serviceTier) request.service_tier = options.serviceTier;\n\n  if (options.promptCacheKey) request.prompt_cache_key = options.promptCacheKey;\n\n  if (options.verbosity || options.outputSchema) {\n    const text: OpenAIResponsesText = {};\n\n    if (options.verbosity) text.verbosity = options.verbosity;\n\n    if (options.outputSchema) {\n      text.format = {\n        type: \"json_schema\",\n        strict: true,\n        schema: options.outputSchema.schema,\n        name: options.outputSchema.name ?? \"codex_output_schema\",\n      };\n    }\n\n    request.text = text;\n  }\n\n  return request;\n}\n\n/** Codex CLI identity headers; correlation headers are present only when supplied. */\nexport type CodexIdentityHeaders = {\n  Accept: \"text/event-stream\";\n  Authorization: string;\n  \"ChatGPT-Account-ID\": string;\n  \"Content-Type\": \"application/json\";\n  originator: typeof CODEX_CLI_ORIGINATOR;\n  \"User-Agent\": string;\n  \"session-id\"?: string;\n  \"thread-id\"?: string;\n  \"x-client-request-id\"?: string;\n};\n\nexport function buildCodexIdentityHeaders(\n  accessToken: string,\n  accountId: string,\n  correlation?: { sessionId?: string; threadId?: string; clientRequestId?: string },\n): CodexIdentityHeaders {\n  const headers: CodexIdentityHeaders = {\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  };\n\n  if (correlation?.sessionId) headers[\"session-id\"] = correlation.sessionId;\n\n  if (correlation?.threadId) headers[\"thread-id\"] = correlation.threadId;\n\n  if (correlation?.clientRequestId) headers[\"x-client-request-id\"] = correlation.clientRequestId;\n\n  return headers;\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; itemId?: string }\n  | {\n      type: \"image\";\n      id?: string;\n      base64: string;\n      mimeType: \"image/png\" | \"image/jpeg\" | \"image/webp\";\n      revisedPrompt?: string;\n      generation?: ImageGenerationMetadata;\n    }\n  | { type: \"output-item\"; item: OpenAIResponseItem; completed?: boolean }\n  | {\n      type: \"completed\";\n      responseId: string;\n      usage?: OpenAIUsage;\n      model?: string;\n      imageGeneration?: ImageGenerationMetadata;\n    }\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\nconst tokenCount = z.coerce.number().catch(0);\n\nfunction jsonObjectOrEmpty(value: JsonValue | undefined): JsonObject {\n  return isJsonObject(value) ? value : {};\n}\n\nfunction usageFrom(value: JsonObject): OpenAIUsage {\n  const inputDetails = jsonObjectOrEmpty(value.input_tokens_details);\n  const outputDetails = jsonObjectOrEmpty(value.output_tokens_details);\n\n  return {\n    inputTokens: tokenCount.parse(value.input_tokens ?? 0),\n    cachedInputTokens: tokenCount.parse(inputDetails.cached_tokens ?? 0),\n    outputTokens: tokenCount.parse(value.output_tokens ?? 0),\n    reasoningTokens: tokenCount.parse(outputDetails.reasoning_tokens ?? 0),\n    totalTokens: tokenCount.parse(value.total_tokens ?? 0),\n  };\n}\n\nexport function imageMimeType(\n  base64: string,\n  outputFormat?: JsonValue,\n): \"image/png\" | \"image/jpeg\" | \"image/webp\" {\n  // Inspect only the header, without decoding a potentially large image twice.\n  const header = Buffer.from(base64.slice(0, 24), \"base64\");\n\n  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))\n    return \"image/png\";\n\n  if (header[0] === 255 && header[1] === 216 && header[2] === 255) return \"image/jpeg\";\n\n  if (header.toString(\"ascii\", 0, 4) === \"RIFF\" && header.toString(\"ascii\", 8, 12) === \"WEBP\")\n    return \"image/webp\";\n\n  if (outputFormat === \"jpeg\") return \"image/jpeg\";\n\n  if (outputFormat === \"webp\") return \"image/webp\";\n\n  if (outputFormat === undefined || outputFormat === \"png\") return \"image/png\";\n  const label = jsonString(outputFormat) ?? JSON.stringify(outputFormat);\n  throw new OpenAIProtocolError(`Unsupported image output format: ${label}`);\n}\n\ntype OpenAIImageEvent = Extract<OpenAINormalizedEvent, { type: \"image\" }>;\n\nfunction imageEvent(item: JsonObject, result: string): OpenAIImageEvent {\n  // PNG exposes dimensions in its fixed header. Other formats retain the\n  // backend's observed size; never substitute requested image controls.\n  const header = Buffer.from(result.slice(0, 32), \"base64\");\n\n  const pngSize =\n    header.length >= 24 &&\n    header.subarray(0, 8).equals(Buffer.from(\"89504e470d0a1a0a\", \"hex\")) &&\n    header.readUInt32BE(16) > 0 &&\n    header.readUInt32BE(20) > 0\n      ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}`\n      : undefined;\n\n  const reportedSize = jsonString(item.size);\n\n  const size =\n    pngSize ??\n    (reportedSize !== undefined && /^[1-9]\\d*x[1-9]\\d*$/.test(reportedSize)\n      ? reportedSize\n      : undefined);\n\n  const id = jsonString(item.id);\n  const model = jsonString(item.model);\n  const quality = jsonString(item.quality);\n  const background = jsonString(item.background);\n  const revisedPrompt = jsonString(item.revised_prompt) ?? jsonString(item.revisedPrompt);\n  const generation: ImageGenerationMetadata = { route: \"codex-responses\" };\n\n  if (size) generation.size = size;\n\n  if (model !== undefined) generation.model = model;\n\n  if (quality !== undefined) generation.quality = quality;\n\n  if (background !== undefined) generation.background = background;\n\n  const event: OpenAIImageEvent = { type: \"image\", base64: result, mimeType: \"image/png\" };\n\n  if (id !== undefined) event.id = id;\n  event.base64 = result;\n  event.mimeType = imageMimeType(result, item.output_format);\n  event.generation = generation;\n\n  if (revisedPrompt !== undefined) event.revisedPrompt = revisedPrompt;\n\n  return event;\n}\n\ntype OpenAICompletedEvent = Extract<OpenAINormalizedEvent, { type: \"completed\" }>;\n\nfunction completedEvent(response: JsonObject): OpenAICompletedEvent {\n  const toolUsage = jsonObjectOrEmpty(response.tool_usage);\n  const parsedImageUsage = ImageGenerationMetadata.shape.usage.safeParse(toolUsage.image_gen);\n  const imageUsage = parsedImageUsage.success ? parsedImageUsage.data : undefined;\n\n  const imageTool = Array.isArray(response.tools)\n    ? response.tools.find((tool) => isJsonObject(tool) && tool.type === \"image_generation\")\n    : undefined;\n\n  const imageModel = isJsonObject(imageTool) ? jsonString(imageTool.model) : undefined;\n  const model = jsonString(response.model);\n\n  const event: OpenAICompletedEvent = {\n    type: \"completed\",\n    responseId: jsonString(response.id) ?? \"\",\n  };\n\n  if (isJsonObject(response.usage)) event.usage = usageFrom(response.usage);\n\n  if (model !== undefined) event.model = model;\n\n  if (imageUsage || imageModel) {\n    const imageGeneration: ImageGenerationMetadata = { route: \"codex-responses\" };\n\n    if (imageModel) imageGeneration.model = imageModel;\n\n    if (imageUsage) imageGeneration.usage = imageUsage;\n    event.imageGeneration = imageGeneration;\n  }\n\n  return event;\n}\n\nexport function normalizeOpenAIEvent(raw: JsonValue): OpenAINormalizedEvent | undefined {\n  if (!isJsonObject(raw)) return undefined;\n  const event = raw;\n  const type = jsonString(event.type) ?? \"\";\n\n  if (type === \"response.created\") {\n    const responseId = isJsonObject(event.response) ? jsonString(event.response.id) : undefined;\n\n    return responseId ? { type: \"created\", responseId } : { type: \"created\" };\n  }\n\n  const delta = jsonString(event.delta);\n\n  if (type === \"response.output_text.delta\" && delta !== undefined) {\n    const itemId = jsonString(event.item_id);\n\n    return itemId === undefined\n      ? { type: \"text-delta\", text: delta }\n      : { type: \"text-delta\", text: delta, itemId };\n  }\n\n  if (\n    (type === \"response.output_item.added\" || type === \"response.output_item.done\") &&\n    isJsonObject(event.item)\n  ) {\n    const item = event.item;\n    const result = jsonString(item.result);\n\n    if (item.type === \"image_generation_call\" && result !== undefined) {\n      return imageEvent(item, result);\n    }\n\n    return { type: \"output-item\", item, completed: type === \"response.output_item.done\" };\n  }\n\n  if (type === \"response.completed\") return completedEvent(jsonObjectOrEmpty(event.response));\n\n  if (type === \"error\" || type === \"response.failed\" || type === \"response.incomplete\") {\n    const source = jsonObjectOrEmpty(event.error ?? event.response ?? event);\n    const nested = jsonObjectOrEmpty(source.error ?? source);\n\n    return {\n      type: \"error\",\n      error: new OpenAIProtocolError(\n        jsonString(nested.message) ?? `OpenAI stream ended with ${type}`,\n        jsonString(nested.code),\n      ),\n    };\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;AAeA,MAAa,8BACX;AAEF,MAAa,uBAAuB;AACpC,MAAa,oBAAoB;AASjC,SAAS,gBAAwC;CAC/C,MAAM,QAAkD;EACtD,QAAQ;EACR,OAAO;EACP,OAAO;CACT;CAEA,MAAM,WAAW,QAAQ,IAAI;CAC7B,MAAM,kBAAkB,QAAQ,IAAI;CAEpC,OAAO;EACL,QAAQ,MAAM,QAAQ,aAAa,QAAQ;EAC3C,WAAW,GAAG,QAAQ;EACtB,cAAc,QAAQ;EACtB,UAAU,WAAW,GAAG,WAAW,kBAAkB,IAAI,oBAAoB,OAAO;CACtF;AACF;;AAGA,SAAgB,kBAAkB,WAAmC,cAAc,GAAW;CAC5F,OAAO,gBAAgB,kBAAkB,IAAI,SAAS,OAAO,GAAG,SAAS,UAAU,IAAI,SAAS,aAAa,IAAI,SAAS;AAC5H;AAuDA,SAAgB,4BACd,SACwB;CACxB,MAAM,QAAQ,QAAQ,QAAQ,CAAC,GAAG,QAAQ,KAAK,IAAI,CAAC;CAEpD,IAAI,QAAQ,iBACV,MAAM,KACJ,QAAQ,oBAAoB,OACxB,EAAE,MAAM,mBAAmB,IAC3B;EAAE,MAAM;EAAoB,GAAG,QAAQ;CAAgB,CAC7D;CAGF,MAAM,UAAkC;EACtC,OAAO,QAAQ;EAEf,OAAO,CAAC,GAAG,QAAQ,OAAO;EAC1B,aAAa,QAAQ,cAAc;EACnC,qBAAqB,QAAQ,qBAAqB;EAClD,WAAW,QAAQ,aAAa;EAChC,OAAO;EACP,QAAQ;EACR,SAAS,CAAC,6BAA6B;CACzC;CAEA,IAAI,QAAQ,cAAc,QAAQ,eAAe,QAAQ;CAEzD,IAAI,MAAM,QAAQ,QAAQ,QAAQ;CAElC,IAAI,QAAQ,aAAa,QAAQ,eAAe,QAAQ;CAExD,IAAI,QAAQ,gBAAgB,QAAQ,mBAAmB,QAAQ;CAE/D,IAAI,QAAQ,aAAa,QAAQ,cAAc;EAC7C,MAAM,OAA4B,CAAC;EAEnC,IAAI,QAAQ,WAAW,KAAK,YAAY,QAAQ;EAEhD,IAAI,QAAQ,cACV,KAAK,SAAS;GACZ,MAAM;GACN,QAAQ;GACR,QAAQ,QAAQ,aAAa;GAC7B,MAAM,QAAQ,aAAa,QAAQ;EACrC;EAGF,QAAQ,OAAO;CACjB;CAEA,OAAO;AACT;AAeA,SAAgB,0BACd,aACA,WACA,aACsB;CACtB,MAAM,UAAgC;EACpC,QAAQ;EACR,eAAe,UAAU;EACzB,sBAAsB;EACtB,gBAAgB;EAChB,YAAY;EACZ,cAAc,kBAAkB;CAClC;CAEA,IAAI,aAAa,WAAW,QAAQ,gBAAgB,YAAY;CAEhE,IAAI,aAAa,UAAU,QAAQ,eAAe,YAAY;CAE9D,IAAI,aAAa,iBAAiB,QAAQ,yBAAyB,YAAY;CAE/E,OAAO;AACT;AA+BA,IAAa,sBAAb,cAAyC,MAAM;CAG3B;CACA;CACA;CAJlB,YACE,SACA,MACA,QACA,cACA;EACA,MAAM,OAAO;EAJG,KAAA,OAAA;EACA,KAAA,SAAA;EACA,KAAA,eAAA;EAGhB,KAAK,OAAO;CACd;AACF;AAEA,MAAM,aAAa,EAAE,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC;AAE5C,SAAS,kBAAkB,OAA0C;CACnE,OAAO,aAAa,KAAK,IAAI,QAAQ,CAAC;AACxC;AAEA,SAAS,UAAU,OAAgC;CACjD,MAAM,eAAe,kBAAkB,MAAM,oBAAoB;CACjE,MAAM,gBAAgB,kBAAkB,MAAM,qBAAqB;CAEnE,OAAO;EACL,aAAa,WAAW,MAAM,MAAM,gBAAgB,CAAC;EACrD,mBAAmB,WAAW,MAAM,aAAa,iBAAiB,CAAC;EACnE,cAAc,WAAW,MAAM,MAAM,iBAAiB,CAAC;EACvD,iBAAiB,WAAW,MAAM,cAAc,oBAAoB,CAAC;EACrE,aAAa,WAAW,MAAM,MAAM,gBAAgB,CAAC;CACvD;AACF;AAEA,SAAgB,cACd,QACA,cAC2C;CAE3C,MAAM,SAAS,OAAO,KAAK,OAAO,MAAM,GAAG,EAAE,GAAG,QAAQ;CAExD,IAAI,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,OAAO,OAAO,KAAK;EAAC;EAAK;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;CAAE,CAAC,CAAC,GAC7E,OAAO;CAET,IAAI,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,KAAK,OAAO;CAExE,IAAI,OAAO,SAAS,SAAS,GAAG,CAAC,MAAM,UAAU,OAAO,SAAS,SAAS,GAAG,EAAE,MAAM,QACnF,OAAO;CAET,IAAI,iBAAiB,QAAQ,OAAO;CAEpC,IAAI,iBAAiB,QAAQ,OAAO;CAEpC,IAAI,iBAAiB,UAAa,iBAAiB,OAAO,OAAO;CAEjE,MAAM,IAAI,oBAAoB,oCADhB,WAAW,YAAY,KAAK,KAAK,UAAU,YAAY,GACI;AAC3E;AAIA,SAAS,WAAW,MAAkB,QAAkC;CAGtE,MAAM,SAAS,OAAO,KAAK,OAAO,MAAM,GAAG,EAAE,GAAG,QAAQ;CAExD,MAAM,UACJ,OAAO,UAAU,MACjB,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,OAAO,OAAO,KAAK,oBAAoB,KAAK,CAAC,KACnE,OAAO,aAAa,EAAE,IAAI,KAC1B,OAAO,aAAa,EAAE,IAAI,IACtB,GAAG,OAAO,aAAa,EAAE,EAAE,GAAG,OAAO,aAAa,EAAE,MACpD;CAEN,MAAM,eAAe,WAAW,KAAK,IAAI;CAEzC,MAAM,OACJ,YACC,iBAAiB,UAAa,sBAAsB,KAAK,YAAY,IAClE,eACA;CAEN,MAAM,KAAK,WAAW,KAAK,EAAE;CAC7B,MAAM,QAAQ,WAAW,KAAK,KAAK;CACnC,MAAM,UAAU,WAAW,KAAK,OAAO;CACvC,MAAM,aAAa,WAAW,KAAK,UAAU;CAC7C,MAAM,gBAAgB,WAAW,KAAK,cAAc,KAAK,WAAW,KAAK,aAAa;CACtF,MAAM,aAAsC,EAAE,OAAO,kBAAkB;CAEvE,IAAI,MAAM,WAAW,OAAO;CAE5B,IAAI,UAAU,QAAW,WAAW,QAAQ;CAE5C,IAAI,YAAY,QAAW,WAAW,UAAU;CAEhD,IAAI,eAAe,QAAW,WAAW,aAAa;CAEtD,MAAM,QAA0B;EAAE,MAAM;EAAS,QAAQ;EAAQ,UAAU;CAAY;CAEvF,IAAI,OAAO,QAAW,MAAM,KAAK;CACjC,MAAM,SAAS;CACf,MAAM,WAAW,cAAc,QAAQ,KAAK,aAAa;CACzD,MAAM,aAAa;CAEnB,IAAI,kBAAkB,QAAW,MAAM,gBAAgB;CAEvD,OAAO;AACT;AAIA,SAAS,eAAe,UAA4C;CAClE,MAAM,YAAY,kBAAkB,SAAS,UAAU;CACvD,MAAM,mBAAmB,wBAAwB,MAAM,MAAM,UAAU,UAAU,SAAS;CAC1F,MAAM,aAAa,iBAAiB,UAAU,iBAAiB,OAAO;CAEtE,MAAM,YAAY,MAAM,QAAQ,SAAS,KAAK,IAC1C,SAAS,MAAM,MAAM,SAAS,aAAa,IAAI,KAAK,KAAK,SAAS,kBAAkB,IACpF;CAEJ,MAAM,aAAa,aAAa,SAAS,IAAI,WAAW,UAAU,KAAK,IAAI;CAC3E,MAAM,QAAQ,WAAW,SAAS,KAAK;CAEvC,MAAM,QAA8B;EAClC,MAAM;EACN,YAAY,WAAW,SAAS,EAAE,KAAK;CACzC;CAEA,IAAI,aAAa,SAAS,KAAK,GAAG,MAAM,QAAQ,UAAU,SAAS,KAAK;CAExE,IAAI,UAAU,QAAW,MAAM,QAAQ;CAEvC,IAAI,cAAc,YAAY;EAC5B,MAAM,kBAA2C,EAAE,OAAO,kBAAkB;EAE5E,IAAI,YAAY,gBAAgB,QAAQ;EAExC,IAAI,YAAY,gBAAgB,QAAQ;EACxC,MAAM,kBAAkB;CAC1B;CAEA,OAAO;AACT;AAEA,SAAgB,qBAAqB,KAAmD;CACtF,IAAI,CAAC,aAAa,GAAG,GAAG,OAAO;CAC/B,MAAM,QAAQ;CACd,MAAM,OAAO,WAAW,MAAM,IAAI,KAAK;CAEvC,IAAI,SAAS,oBAAoB;EAC/B,MAAM,aAAa,aAAa,MAAM,QAAQ,IAAI,WAAW,MAAM,SAAS,EAAE,IAAI;EAElF,OAAO,aAAa;GAAE,MAAM;GAAW;EAAW,IAAI,EAAE,MAAM,UAAU;CAC1E;CAEA,MAAM,QAAQ,WAAW,MAAM,KAAK;CAEpC,IAAI,SAAS,gCAAgC,UAAU,QAAW;EAChE,MAAM,SAAS,WAAW,MAAM,OAAO;EAEvC,OAAO,WAAW,SACd;GAAE,MAAM;GAAc,MAAM;EAAM,IAClC;GAAE,MAAM;GAAc,MAAM;GAAO;EAAO;CAChD;CAEA,KACG,SAAS,gCAAgC,SAAS,gCACnD,aAAa,MAAM,IAAI,GACvB;EACA,MAAM,OAAO,MAAM;EACnB,MAAM,SAAS,WAAW,KAAK,MAAM;EAErC,IAAI,KAAK,SAAS,2BAA2B,WAAW,QACtD,OAAO,WAAW,MAAM,MAAM;EAGhC,OAAO;GAAE,MAAM;GAAe;GAAM,WAAW,SAAS;EAA4B;CACtF;CAEA,IAAI,SAAS,sBAAsB,OAAO,eAAe,kBAAkB,MAAM,QAAQ,CAAC;CAE1F,IAAI,SAAS,WAAW,SAAS,qBAAqB,SAAS,uBAAuB;EACpF,MAAM,SAAS,kBAAkB,MAAM,SAAS,MAAM,YAAY,KAAK;EACvE,MAAM,SAAS,kBAAkB,OAAO,SAAS,MAAM;EAEvD,OAAO;GACL,MAAM;GACN,OAAO,IAAI,oBACT,WAAW,OAAO,OAAO,KAAK,4BAA4B,QAC1D,WAAW,OAAO,IAAI,CACxB;EACF;CACF;AAGF"}