@cartanova/qgrid-cli 2.10.10 → 2.11.1

package/bundle/src/utils/providers/openai/openai-image-generation.ts

@@ -2,6 +2,7 @@ import { PNG } from "pngjs";
 import { z } from "zod";
 
 import { ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
+import { isJsonObject, type JsonValue, jsonString } from "../common/provider-types";
 import {
   CHATGPT_CODEX_RESPONSES_URL,
   imageMimeType,
@@ -14,6 +15,21 @@ const MAX_PNG_BYTES = 32 * 1024 * 1024;
 const MAX_IMAGE_PIXELS = 4096 * 4096;
 const MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
 const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const TEXT_PART_TYPES = new Set(["input_text", "output_text", "text"]);
+
+/** Request body for the standalone Codex images endpoint; controls are forwarded only when set. */
+type StandaloneImageBody = {
+  model: "gpt-image-2";
+  prompt: string;
+  background?: JsonValue;
+  quality?: JsonValue;
+  size?: JsonValue;
+  images?: Array<{ image_url: string }>;
+};
+
+function imageUrlOf(value: JsonValue | undefined): string | undefined {
+  return jsonString(value) ?? (isJsonObject(value) ? jsonString(value.url) : undefined);
+}
 
 export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
   if (options.outputSchema || options.tools?.length) {
@@ -21,88 +37,126 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
       "Standalone image generation does not support tools or structured output",
     );
   }
+
   if (!options.imageGeneration) {
     throw new OpenAIProtocolError("Standalone images require image generation to be enabled");
   }
-  const controls = typeof options.imageGeneration === "object" ? options.imageGeneration : {};
+
+  const controls = options.imageGeneration === true ? {} : options.imageGeneration;
+
   if (options.model !== "gpt-image-2" && controls.background !== "transparent") {
     throw new OpenAIProtocolError(
       "Standalone images require an explicit transparent background request",
     );
   }
+
   if (controls.output_format && controls.output_format !== "png") {
     throw new OpenAIProtocolError("Standalone image generation only supports PNG output");
   }
+
   const text: string[] = [];
   const images: Array<{ image_url: string }> = [];
+
   if (options.instructions) text.push(`System instructions:\n${options.instructions}`);
+
   for (const item of options.history) {
+    if (!isJsonObject(item)) {
+      throw new OpenAIProtocolError(
+        "Unsupported conversation item for standalone image generation",
+      );
+    }
+
     if (item.type === "reasoning") continue;
-    if (item.type === "image_generation_call" && typeof item.result === "string") {
+
+    const result = jsonString(item.result);
+
+    if (item.type === "image_generation_call" && result !== undefined) {
       images.push({
-        image_url: `data:${imageMimeType(item.result, item.output_format)};base64,${item.result}`,
+        image_url: `data:${imageMimeType(result, item.output_format)};base64,${result}`,
       });
       continue;
     }
-    if (item.type !== "message" && typeof item.role !== "string") {
+
+    const role = jsonString(item.role);
+
+    if (item.type !== "message" && role === undefined) {
       throw new OpenAIProtocolError(
         "Unsupported conversation item for standalone image generation",
       );
     }
-    if (typeof item.content === "string") {
-      text.push(`${item.role ?? "user"}:\n${item.content}`);
+
+    const speaker = role ?? "user";
+    const content = jsonString(item.content);
+
+    if (content !== undefined) {
+      text.push(`${speaker}:\n${content}`);
       continue;
     }
+
     if (!Array.isArray(item.content)) {
       throw new OpenAIProtocolError("Unsupported message content for standalone image generation");
     }
+
     for (const part of item.content) {
-      if (!part || typeof part !== "object") {
+      if (!isJsonObject(part)) {
         throw new OpenAIProtocolError("Unsupported message part for standalone image generation");
       }
-      if (
-        ["input_text", "output_text", "text"].includes(part.type) &&
-        typeof part.text === "string"
-      ) {
-        text.push(`${item.role ?? "user"}:\n${part.text}`);
+
+      const partType = jsonString(part.type);
+      const partText = jsonString(part.text);
+
+      if (partType !== undefined && TEXT_PART_TYPES.has(partType) && partText !== undefined) {
+        text.push(`${speaker}:\n${partText}`);
       } else if (part.type === "input_image" || part.type === "image_url") {
-        const url = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
-        if (typeof url !== "string" || !/^(https:\/\/|data:image\/)/i.test(url)) {
+        const url = imageUrlOf(part.image_url);
+
+        if (url === undefined || !/^(https:\/\/|data:image\/)/i.test(url)) {
           throw new OpenAIProtocolError("Image references must be HTTPS URLs or image data URLs");
         }
+
         images.push({ image_url: url });
       } else {
         throw new OpenAIProtocolError("Unsupported message part for standalone image generation");
       }
     }
   }
+
   if (images.length > 5)
     throw new OpenAIProtocolError("Standalone image editing supports at most 5 reference images");
+
   if (!text.some((part) => part.trim())) throw new OpenAIProtocolError("Image prompt is empty");
+
+  const body: StandaloneImageBody = { model: "gpt-image-2", prompt: text.join("\n\n") };
+
+  if (controls.background) body.background = controls.background;
+
+  if (controls.quality) body.quality = controls.quality;
+
+  if (controls.size) body.size = controls.size;
+
+  if (images.length) body.images = images;
+
   return {
     url: CHATGPT_CODEX_RESPONSES_URL.replace(
       /\/responses$/,
       `/images/${images.length ? "edits" : "generations"}`,
     ),
-    body: {
-      model: "gpt-image-2",
-      prompt: text.join("\n\n"),
-      ...(controls.background ? { background: controls.background } : {}),
-      ...(controls.quality ? { quality: controls.quality } : {}),
-      ...(controls.size ? { size: controls.size } : {}),
-      ...(images.length ? { images } : {}),
-    },
+    body,
   };
 }
 
-function inspectGeneratedPng(
-  base64: string,
-  requireTransparency: boolean,
-): { width: number; height: number } {
+interface PngDimensions {
+  width: number;
+  height: number;
+}
+
+function inspectGeneratedPng(base64: string, requireTransparency: boolean): PngDimensions {
   if (base64.length > Math.ceil(MAX_PNG_BYTES / 3) * 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
     throw new OpenAIProtocolError("Invalid or oversized generated PNG");
   }
+
   const bytes = Buffer.from(base64, "base64");
+
   if (
     bytes.length < 33 ||
     !bytes.subarray(0, 8).equals(PNG_SIGNATURE) ||
@@ -110,26 +164,34 @@ function inspectGeneratedPng(
   ) {
     throw new OpenAIProtocolError("Image generation did not return a PNG");
   }
+
   const width = bytes.readUInt32BE(16);
   const height = bytes.readUInt32BE(20);
+
   if (!width || !height || width * height > MAX_IMAGE_PIXELS) {
     throw new OpenAIProtocolError("Generated PNG dimensions exceed the decoding limit");
   }
+
   let image: PNG;
+
   try {
     image = PNG.sync.read(bytes);
   } catch {
     throw new OpenAIProtocolError("Image generation returned an invalid PNG");
   }
+
   if (!requireTransparency) return { width: image.width, height: image.height };
   // An alpha channel alone can still be fully opaque or have no visible content.
   let transparent = false;
   let visible = false;
+
   for (let i = 3; i < image.data.length; i += 4) {
     transparent ||= image.data[i] === 0;
     visible ||= image.data[i]! > 0;
+
     if (transparent && visible) return { width: image.width, height: image.height };
   }
+
   throw new OpenAIProtocolError(
     "Image generation did not return visible content on a transparent background",
   );
@@ -143,20 +205,25 @@ export async function readStandaloneImageResponse(
   const reader = response.body.getReader();
   const chunks: Uint8Array[] = [];
   let size = 0;
+
   try {
     while (true) {
       const { done, value } = await reader.read();
+
       if (done) break;
       size += value.byteLength;
+
       if (size > MAX_RESPONSE_BYTES) {
         await reader.cancel();
         throw new OpenAIProtocolError("Image response exceeded the size limit");
       }
+
       chunks.push(value);
     }
   } finally {
     reader.releaseLock();
   }
+
   const schema = z.object({
     data: z
       .array(z.object({ b64_json: z.string().min(1), revised_prompt: z.string().nullish() }))
@@ -167,28 +234,41 @@ export async function readStandaloneImageResponse(
     background: z.string().optional(),
     usage: ImageGenerationMetadata.shape.usage,
   });
+
   let parsed: z.infer<typeof schema>;
+
   try {
     parsed = schema.parse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
   } catch {
     throw new OpenAIProtocolError("Invalid standalone image response");
   }
+
   const background = parsed.background ?? (requireTransparency ? "transparent" : undefined);
+
   return parsed.data.map((item, index) => {
     const dimensions = inspectGeneratedPng(item.b64_json, requireTransparency);
-    return {
+
+    const generation: ImageGenerationMetadata = {
+      route: "codex-images",
+      model: parsed.model ?? "gpt-image-2",
+      size: `${dimensions.width}x${dimensions.height}`,
+    };
+
+    if (background) generation.background = background;
+
+    if (parsed.quality) generation.quality = parsed.quality;
+
+    if (index === 0 && parsed.usage) generation.usage = parsed.usage;
+
+    const event: OpenAINormalizedEvent = {
       type: "image",
       base64: item.b64_json,
       mimeType: "image/png",
-      ...(item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {}),
-      generation: {
-        route: "codex-images",
-        model: parsed.model ?? "gpt-image-2",
-        ...(background ? { background } : {}),
-        size: `${dimensions.width}x${dimensions.height}`,
-        ...(parsed.quality ? { quality: parsed.quality } : {}),
-        ...(index === 0 && parsed.usage ? { usage: parsed.usage } : {}),
-      },
+      generation,
     };
+
+    if (item.revised_prompt) event.revisedPrompt = item.revised_prompt;
+
+    return event;
   });
 }

package/bundle/src/utils/providers/openai/openai-oauth.ts

@@ -1,5 +1,8 @@
 import crypto from "node:crypto";
 
+import { z } from "zod";
+
+import { type JsonValue } from "../common/provider-types";
 import {
   OPENAI_AUTHORIZE_URL,
   OPENAI_CLIENT_ID,
@@ -10,6 +13,25 @@ import {
 
 const OPENAI_AUTH_CLAIM = "https://api.openai.com/auth";
 
+// Mistyped claims read as absent, matching how the callers treat missing ones.
+const openAITokenClaimsSchema = z.looseObject({
+  exp: z.number().optional().catch(undefined),
+  [OPENAI_AUTH_CLAIM]: z
+    .looseObject({
+      chatgpt_account_id: z.string().optional().catch(undefined),
+      chatgpt_plan_type: z.string().optional().catch(undefined),
+    })
+    .optional()
+    .catch(undefined),
+});
+
+const openAITokenExchangeResponseSchema = z.looseObject({
+  id_token: z.string().optional(),
+  access_token: z.string().optional(),
+  refresh_token: z.string().optional(),
+  expires_in: z.number().optional(),
+});
+
 export interface OpenAIPKCE {
   codeVerifier: string;
   codeChallenge: string;
@@ -34,6 +56,7 @@ export interface OpenAIExchangedCredentials {
 
 export function generateOpenAIPKCE(): OpenAIPKCE {
   const codeVerifier = crypto.randomBytes(64).toString("base64url");
+
   return {
     codeVerifier,
     codeChallenge: crypto.createHash("sha256").update(codeVerifier).digest("base64url"),
@@ -59,32 +82,36 @@ export function buildOpenAIAuthUrl(
     state,
     originator: OPENAI_ORIGINATOR,
   }).toString();
+
   return url.toString();
 }
 
 export function parseOpenAITokenClaims(jwt: string): OpenAITokenClaims {
   const parts = jwt.split(".");
   const payloadPart = parts[1];
+
   if (parts.length !== 3 || parts.some((part) => !part) || !payloadPart) {
     throw new Error("invalid OpenAI JWT format");
   }
 
-  let payload: unknown;
+  let payload: JsonValue;
+
   try {
+    // JSON.parse without a reviver yields only JSON values.
     payload = JSON.parse(Buffer.from(payloadPart, "base64url").toString("utf8"));
   } catch {
     throw new Error("invalid OpenAI JWT payload");
   }
-  if (!payload || typeof payload !== "object") throw new Error("invalid OpenAI JWT payload");
 
-  const claims = payload as Record<string, unknown>;
-  const auth = claims[OPENAI_AUTH_CLAIM];
-  const nested = auth && typeof auth === "object" ? (auth as Record<string, unknown>) : {};
+  const claims = openAITokenClaimsSchema.safeParse(payload);
+
+  if (!claims.success) throw new Error("invalid OpenAI JWT payload");
+  const auth = claims.data[OPENAI_AUTH_CLAIM];
+
   return {
-    expiresAt: typeof claims.exp === "number" ? claims.exp * 1000 : undefined,
-    accountId:
-      typeof nested.chatgpt_account_id === "string" ? nested.chatgpt_account_id : undefined,
-    planType: typeof nested.chatgpt_plan_type === "string" ? nested.chatgpt_plan_type : undefined,
+    expiresAt: claims.data.exp === undefined ? undefined : claims.data.exp * 1000,
+    accountId: auth?.chatgpt_account_id,
+    planType: auth?.chatgpt_plan_type,
   };
 }
 
@@ -104,18 +131,15 @@ export async function exchangeOpenAICode(
       code_verifier: codeVerifier,
     }),
   });
+
   if (!response.ok) {
     // Token endpoint bodies can echo credentials or provider diagnostics; never expose them.
     await response.body?.cancel().catch(() => undefined);
     throw new Error(`OPENAI_TOKEN_EXCHANGE_HTTP_${response.status}`);
   }
 
-  const tokens = (await response.json()) as {
-    id_token?: string;
-    access_token?: string;
-    refresh_token?: string;
-    expires_in?: number;
-  };
+  const tokens = openAITokenExchangeResponseSchema.parse(await response.json());
+
   if (!tokens.id_token || !tokens.access_token || !tokens.refresh_token) {
     throw new Error("OpenAI token exchange returned incomplete credentials");
   }
@@ -123,19 +147,23 @@ export async function exchangeOpenAICode(
   const idClaims = parseOpenAITokenClaims(tokens.id_token);
   const accessClaims = parseOpenAITokenClaims(tokens.access_token);
   const accountId = idClaims.accountId ?? accessClaims.accountId;
+
   if (!accountId) throw new Error("OpenAI token did not include a ChatGPT account id");
 
-  return {
+  const credentials: OpenAIExchangedCredentials = {
     accessToken: tokens.access_token,
     refreshToken: tokens.refresh_token,
     idToken: tokens.id_token,
     accessTokenExpiresAt:
       accessClaims.expiresAt ??
       (tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : Date.now()),
-    ...(idClaims.expiresAt ? { idTokenExpiresAt: idClaims.expiresAt } : {}),
     accountId,
-    ...((idClaims.planType ?? accessClaims.planType)
-      ? { planType: idClaims.planType ?? accessClaims.planType }
-      : {}),
   };
+
+  if (idClaims.expiresAt) credentials.idTokenExpiresAt = idClaims.expiresAt;
+  const planType = idClaims.planType ?? accessClaims.planType;
+
+  if (planType) credentials.planType = planType;
+
+  return credentials;
 }

package/bundle/src/utils/providers/openai/openai-quota.ts

@@ -1,5 +1,13 @@
 import { type OpenAICredentials } from "../../../application/token/token.types";
-import { type QuotaRateLimits, type QuotaRateLimitSnapshot } from "../common/provider-types";
+import {
+  isJsonObject,
+  type JsonObject,
+  type JsonValue,
+  jsonString,
+  type QuotaRateLimits,
+  type QuotaRateLimitSnapshot,
+  type QuotaRateLimitWindow,
+} from "../common/provider-types";
 import { buildCodexIdentityHeaders } from "./openai-backend-protocol";
 
 export const CHATGPT_WHAM_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage" as const;
@@ -33,9 +41,11 @@ async function readDirect(options: OpenAIQuotaHttpOptions): Promise<OpenAIRateLi
     (options.fetch ?? fetch)(CHATGPT_WHAM_USAGE_URL, {
       method: "GET",
       headers: buildCodexIdentityHeaders(credentials.accessToken, credentials.accountId),
-      ...(options.signal ? { signal: options.signal } : {}),
+      signal: options.signal,
     });
+
   let response = await read(options.credentials);
+
   if (response.status === 401 && options.refreshCredentials) {
     await response.body?.cancel();
     options.signal?.throwIfAborted();
@@ -43,20 +53,29 @@ async function readDirect(options: OpenAIQuotaHttpOptions): Promise<OpenAIRateLi
     options.signal?.throwIfAborted();
     response = await read(credentials);
   }
+
   if (!response.ok) throw new Error(`OpenAI quota lookup failed: HTTP ${response.status}`);
-  const body = (await response.json()) as Record<string, unknown>;
+  // Response.json() parses JSON text, which yields only JSON values.
+  const body: JsonValue = await response.json();
   const data = normalizeWhamUsage(body);
+
   return { data, cachedAt: Date.now() };
 }
 
-function windowFrom(value: unknown) {
-  if (!value || typeof value !== "object") return null;
-  const source = value as Record<string, unknown>;
+function jsonObjectOrEmpty(value: JsonValue | undefined): JsonObject {
+  return isJsonObject(value) ? value : {};
+}
+
+function windowFrom(value: JsonValue | undefined): QuotaRateLimitWindow | null {
+  if (!isJsonObject(value)) return null;
+  const source = value;
   const usedPercent = Number(source.usedPercent ?? source.used_percent);
+
   if (!Number.isFinite(usedPercent)) return null;
   const durationMins = source.windowDurationMins ?? source.window_minutes;
   const durationSeconds = source.limitWindowSeconds ?? source.limit_window_seconds;
   const resets = source.resetsAt ?? source.reset_at;
+
   return {
     usedPercent,
     windowDurationMins:
@@ -69,62 +88,75 @@ function windowFrom(value: unknown) {
   };
 }
 
-function snapshotFrom(value: unknown): QuotaRateLimitSnapshot {
-  const source = (value && typeof value === "object" ? value : {}) as Record<string, unknown>;
-  const limitId = source.limitId ?? source.limit_id;
-  const limitName = source.limitName ?? source.limit_name;
+function snapshotFrom(value: JsonValue | undefined): QuotaRateLimitSnapshot {
+  const source = jsonObjectOrEmpty(value);
+
   return {
-    limitId: typeof limitId === "string" ? limitId : null,
-    limitName: typeof limitName === "string" ? limitName : null,
+    limitId: jsonString(source.limitId ?? source.limit_id) ?? null,
+    limitName: jsonString(source.limitName ?? source.limit_name) ?? null,
     primary: windowFrom(source.primary ?? source.primary_window),
     secondary: windowFrom(source.secondary ?? source.secondary_window),
-    credits: (source.credits ?? null) as QuotaRateLimitSnapshot["credits"],
-    planType:
-      typeof (source.planType ?? source.plan_type) === "string"
-        ? String(source.planType ?? source.plan_type)
-        : null,
+    credits: source.credits ?? null,
+    planType: jsonString(source.planType ?? source.plan_type) ?? null,
     rateLimitReachedType:
-      typeof (source.rateLimitReachedType ?? source.rate_limit_reached) === "string"
-        ? String(source.rateLimitReachedType ?? source.rate_limit_reached)
-        : null,
+      jsonString(source.rateLimitReachedType ?? source.rate_limit_reached) ?? null,
   };
 }
 
-function normalizeWhamUsage(body: Record<string, unknown>): QuotaRateLimits {
-  if (body.rateLimits && typeof body.rateLimits === "object") {
-    return body as QuotaRateLimits;
-  }
-  const container =
-    body.rate_limits && typeof body.rate_limits === "object"
-      ? (body.rate_limits as Record<string, unknown>)
-      : body;
-  const shared = {
+/** Normalizes snapshots that already use the app-server (camelCase) shape. */
+function normalizeAppServerUsage(body: JsonObject): QuotaRateLimits {
+  const byId = isJsonObject(body.rateLimitsByLimitId)
+    ? Object.fromEntries(
+        Object.entries(body.rateLimitsByLimitId).map(([id, snapshot]) => [
+          id,
+          snapshotFrom(snapshot),
+        ]),
+      )
+    : null;
+
+  return { rateLimits: snapshotFrom(body.rateLimits), rateLimitsByLimitId: byId };
+}
+
+function normalizeWhamUsage(value: JsonValue): QuotaRateLimits {
+  const body = jsonObjectOrEmpty(value);
+
+  if (isJsonObject(body.rateLimits)) return normalizeAppServerUsage(body);
+
+  const container = isJsonObject(body.rate_limits) ? body.rate_limits : body;
+
+  const shared: JsonObject = {
     plan_type: body.plan_type ?? container.plan_type,
     credits: body.credits ?? container.credits,
     rate_limit_reached: body.rate_limit_reached ?? container.rate_limit_reached,
   };
+
   const primary = snapshotFrom({
     ...shared,
-    ...((container.rate_limit ?? container) as Record<string, unknown>),
+    ...jsonObjectOrEmpty(container.rate_limit ?? container),
   });
+
   const additional = Array.isArray(container.additional_rate_limits)
     ? container.additional_rate_limits
     : Array.isArray(body.additional_rate_limits)
       ? body.additional_rate_limits
       : [];
-  const byId: Record<string, QuotaRateLimitSnapshot> = {};
+
+  const byId = new Map<string, QuotaRateLimitSnapshot>();
+
   for (const entry of additional) {
-    if (!entry || typeof entry !== "object") continue;
-    const wrapper = entry as Record<string, unknown>;
+    if (!isJsonObject(entry)) continue;
+
     const snapshot = snapshotFrom({
       ...shared,
-      ...((wrapper.rate_limit ?? wrapper) as Record<string, unknown>),
+      ...jsonObjectOrEmpty(entry.rate_limit ?? entry),
     });
-    if (snapshot.limitId) byId[snapshot.limitId] = snapshot;
+
+    if (snapshot.limitId) byId.set(snapshot.limitId, snapshot);
   }
+
   return {
     rateLimits: primary,
-    rateLimitsByLimitId: Object.keys(byId).length ? byId : null,
+    rateLimitsByLimitId: byId.size ? Object.fromEntries(byId) : null,
   };
 }
 
@@ -132,29 +164,28 @@ export async function readOpenAIQuotaUsage(
   source: (() => Promise<OpenAIRateLimitsWithMeta>) | OpenAIQuotaHttpOptions,
 ): Promise<OpenAIQuotaUsageResult> {
   try {
-    const direct = typeof source !== "function";
-    const { data, cachedAt } = await (typeof source === "function" ? source() : readDirect(source));
+    const direct = "credentials" in source;
+    const { data, cachedAt } = await ("credentials" in source ? readDirect(source) : source());
     const rateLimits = data.rateLimits;
     const primary = rateLimits?.primary;
 
-    if (
-      !primary ||
-      typeof primary.usedPercent !== "number" ||
-      !Number.isFinite(primary.usedPercent)
-    ) {
+    if (!primary || !Number.isFinite(primary.usedPercent)) {
       return { kind: "lookup_failed", reason: "primary usedPercent unavailable" };
     }
 
-    return {
+    const result: OpenAIQuotaUsageResult = {
       kind: "ok",
       utilizationPct: primary.usedPercent,
       cacheAgeMs: Math.max(Date.now() - cachedAt, 0),
       windowDurationMins: primary.windowDurationMins,
       resetsAt: primary.resetsAt,
       limitId: rateLimits.limitId,
-      ...(direct ? { raw: data } : {}),
     };
+
+    if (direct) result.raw = data;
+
+    return result;
   } catch (e) {
-    return { kind: "lookup_failed", reason: (e as Error).message };
+    return { kind: "lookup_failed", reason: e instanceof Error ? e.message : String(e) };
   }
 }