@cartanova/qgrid-cli 2.7.1 → 2.7.2

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

@@ -0,0 +1,84 @@
+import { OPENAI_AUTHORIZE_URL, OPENAI_CLIENT_ID, OPENAI_ORIGINATOR, OPENAI_SCOPES, OPENAI_TOKEN_URL } from "./openai-constants.js";
+import crypto from "node:crypto";
+//#region src/utils/providers/openai/openai-oauth.ts
+const OPENAI_AUTH_CLAIM = "https://api.openai.com/auth";
+function generateOpenAIPKCE() {
+	const codeVerifier = crypto.randomBytes(64).toString("base64url");
+	return {
+		codeVerifier,
+		codeChallenge: crypto.createHash("sha256").update(codeVerifier).digest("base64url"),
+		state: crypto.randomBytes(32).toString("base64url")
+	};
+}
+function buildOpenAIAuthUrl(codeChallenge, state, redirectUri) {
+	const url = new URL(OPENAI_AUTHORIZE_URL);
+	url.search = new URLSearchParams({
+		response_type: "code",
+		client_id: OPENAI_CLIENT_ID,
+		redirect_uri: redirectUri,
+		scope: OPENAI_SCOPES,
+		code_challenge: codeChallenge,
+		code_challenge_method: "S256",
+		id_token_add_organizations: "true",
+		codex_cli_simplified_flow: "true",
+		state,
+		originator: OPENAI_ORIGINATOR
+	}).toString();
+	return url.toString();
+}
+function parseOpenAITokenClaims(jwt) {
+	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;
+	try {
+		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;
+	const auth = claims[OPENAI_AUTH_CLAIM];
+	const nested = auth && typeof auth === "object" ? auth : {};
+	return {
+		expiresAt: typeof claims.exp === "number" ? claims.exp * 1e3 : void 0,
+		accountId: typeof nested.chatgpt_account_id === "string" ? nested.chatgpt_account_id : void 0,
+		planType: typeof nested.chatgpt_plan_type === "string" ? nested.chatgpt_plan_type : void 0
+	};
+}
+async function exchangeOpenAICode(code, codeVerifier, redirectUri) {
+	const response = await fetch(OPENAI_TOKEN_URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "authorization_code",
+			code,
+			redirect_uri: redirectUri,
+			client_id: OPENAI_CLIENT_ID,
+			code_verifier: codeVerifier
+		})
+	});
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		throw new Error(`OPENAI_TOKEN_EXCHANGE_HTTP_${response.status}`);
+	}
+	const tokens = await response.json();
+	if (!tokens.id_token || !tokens.access_token || !tokens.refresh_token) throw new Error("OpenAI token exchange returned incomplete credentials");
+	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 {
+		accessToken: tokens.access_token,
+		refreshToken: tokens.refresh_token,
+		idToken: tokens.id_token,
+		accessTokenExpiresAt: accessClaims.expiresAt ?? (tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : Date.now()),
+		...idClaims.expiresAt ? { idTokenExpiresAt: idClaims.expiresAt } : {},
+		accountId,
+		...idClaims.planType ?? accessClaims.planType ? { planType: idClaims.planType ?? accessClaims.planType } : {}
+	};
+}
+//#endregion
+export { buildOpenAIAuthUrl, exchangeOpenAICode, generateOpenAIPKCE, parseOpenAITokenClaims };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-oauth.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-oauth.ts"],"sourcesContent":["import crypto from \"node:crypto\";\n\nimport {\n  OPENAI_AUTHORIZE_URL,\n  OPENAI_CLIENT_ID,\n  OPENAI_ORIGINATOR,\n  OPENAI_SCOPES,\n  OPENAI_TOKEN_URL,\n} from \"./openai-constants\";\n\nconst OPENAI_AUTH_CLAIM = \"https://api.openai.com/auth\";\n\nexport interface OpenAIPKCE {\n  codeVerifier: string;\n  codeChallenge: string;\n  state: string;\n}\n\nexport interface OpenAITokenClaims {\n  expiresAt?: number;\n  accountId?: string;\n  planType?: string;\n}\n\nexport interface OpenAIExchangedCredentials {\n  accessToken: string;\n  refreshToken: string;\n  idToken: string;\n  accessTokenExpiresAt: number;\n  idTokenExpiresAt?: number;\n  accountId: string;\n  planType?: string;\n}\n\nexport function generateOpenAIPKCE(): OpenAIPKCE {\n  const codeVerifier = crypto.randomBytes(64).toString(\"base64url\");\n  return {\n    codeVerifier,\n    codeChallenge: crypto.createHash(\"sha256\").update(codeVerifier).digest(\"base64url\"),\n    state: crypto.randomBytes(32).toString(\"base64url\"),\n  };\n}\n\nexport function buildOpenAIAuthUrl(\n  codeChallenge: string,\n  state: string,\n  redirectUri: string,\n): string {\n  const url = new URL(OPENAI_AUTHORIZE_URL);\n  url.search = new URLSearchParams({\n    response_type: \"code\",\n    client_id: OPENAI_CLIENT_ID,\n    redirect_uri: redirectUri,\n    scope: OPENAI_SCOPES,\n    code_challenge: codeChallenge,\n    code_challenge_method: \"S256\",\n    id_token_add_organizations: \"true\",\n    codex_cli_simplified_flow: \"true\",\n    state,\n    originator: OPENAI_ORIGINATOR,\n  }).toString();\n  return url.toString();\n}\n\nexport function parseOpenAITokenClaims(jwt: string): OpenAITokenClaims {\n  const parts = jwt.split(\".\");\n  const payloadPart = parts[1];\n  if (parts.length !== 3 || parts.some((part) => !part) || !payloadPart) {\n    throw new Error(\"invalid OpenAI JWT format\");\n  }\n\n  let payload: unknown;\n  try {\n    payload = JSON.parse(Buffer.from(payloadPart, \"base64url\").toString(\"utf8\"));\n  } catch {\n    throw new Error(\"invalid OpenAI JWT payload\");\n  }\n  if (!payload || typeof payload !== \"object\") throw new Error(\"invalid OpenAI JWT payload\");\n\n  const claims = payload as Record<string, unknown>;\n  const auth = claims[OPENAI_AUTH_CLAIM];\n  const nested = auth && typeof auth === \"object\" ? (auth as Record<string, unknown>) : {};\n  return {\n    expiresAt: typeof claims.exp === \"number\" ? claims.exp * 1000 : undefined,\n    accountId:\n      typeof nested.chatgpt_account_id === \"string\" ? nested.chatgpt_account_id : undefined,\n    planType: typeof nested.chatgpt_plan_type === \"string\" ? nested.chatgpt_plan_type : undefined,\n  };\n}\n\nexport async function exchangeOpenAICode(\n  code: string,\n  codeVerifier: string,\n  redirectUri: string,\n): Promise<OpenAIExchangedCredentials> {\n  const response = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"authorization_code\",\n      code,\n      redirect_uri: redirectUri,\n      client_id: OPENAI_CLIENT_ID,\n      code_verifier: codeVerifier,\n    }),\n  });\n  if (!response.ok) {\n    // Token endpoint bodies can echo credentials or provider diagnostics; never expose them.\n    await response.body?.cancel().catch(() => undefined);\n    throw new Error(`OPENAI_TOKEN_EXCHANGE_HTTP_${response.status}`);\n  }\n\n  const tokens = (await response.json()) as {\n    id_token?: string;\n    access_token?: string;\n    refresh_token?: string;\n    expires_in?: number;\n  };\n  if (!tokens.id_token || !tokens.access_token || !tokens.refresh_token) {\n    throw new Error(\"OpenAI token exchange returned incomplete credentials\");\n  }\n\n  const idClaims = parseOpenAITokenClaims(tokens.id_token);\n  const accessClaims = parseOpenAITokenClaims(tokens.access_token);\n  const accountId = idClaims.accountId ?? accessClaims.accountId;\n  if (!accountId) throw new Error(\"OpenAI token did not include a ChatGPT account id\");\n\n  return {\n    accessToken: tokens.access_token,\n    refreshToken: tokens.refresh_token,\n    idToken: tokens.id_token,\n    accessTokenExpiresAt:\n      accessClaims.expiresAt ??\n      (tokens.expires_in ? Date.now() + tokens.expires_in * 1000 : Date.now()),\n    ...(idClaims.expiresAt ? { idTokenExpiresAt: idClaims.expiresAt } : {}),\n    accountId,\n    ...((idClaims.planType ?? accessClaims.planType)\n      ? { planType: idClaims.planType ?? accessClaims.planType }\n      : {}),\n  };\n}\n"],"mappings":";;;AAUA,MAAM,oBAAoB;AAwB1B,SAAgB,qBAAiC;CAC/C,MAAM,eAAe,OAAO,YAAY,EAAE,CAAC,CAAC,SAAS,WAAW;CAChE,OAAO;EACL;EACA,eAAe,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,YAAY,CAAC,CAAC,OAAO,WAAW;EAClF,OAAO,OAAO,YAAY,EAAE,CAAC,CAAC,SAAS,WAAW;CACpD;AACF;AAEA,SAAgB,mBACd,eACA,OACA,aACQ;CACR,MAAM,MAAM,IAAI,IAAI,oBAAoB;CACxC,IAAI,SAAS,IAAI,gBAAgB;EAC/B,eAAe;EACf,WAAW;EACX,cAAc;EACd,OAAO;EACP,gBAAgB;EAChB,uBAAuB;EACvB,4BAA4B;EAC5B,2BAA2B;EAC3B;EACA,YAAY;CACd,CAAC,CAAC,CAAC,SAAS;CACZ,OAAO,IAAI,SAAS;AACtB;AAEA,SAAgB,uBAAuB,KAAgC;CACrE,MAAM,QAAQ,IAAI,MAAM,GAAG;CAC3B,MAAM,cAAc,MAAM;CAC1B,IAAI,MAAM,WAAW,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI,KAAK,CAAC,aACxD,MAAM,IAAI,MAAM,2BAA2B;CAG7C,IAAI;CACJ,IAAI;EACF,UAAU,KAAK,MAAM,OAAO,KAAK,aAAa,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC;CAC7E,QAAQ;EACN,MAAM,IAAI,MAAM,4BAA4B;CAC9C;CACA,IAAI,CAAC,WAAW,OAAO,YAAY,UAAU,MAAM,IAAI,MAAM,4BAA4B;CAEzF,MAAM,SAAS;CACf,MAAM,OAAO,OAAO;CACpB,MAAM,SAAS,QAAQ,OAAO,SAAS,WAAY,OAAmC,CAAC;CACvF,OAAO;EACL,WAAW,OAAO,OAAO,QAAQ,WAAW,OAAO,MAAM,MAAO;EAChE,WACE,OAAO,OAAO,uBAAuB,WAAW,OAAO,qBAAqB;EAC9E,UAAU,OAAO,OAAO,sBAAsB,WAAW,OAAO,oBAAoB;CACtF;AACF;AAEA,eAAsB,mBACpB,MACA,cACA,aACqC;CACrC,MAAM,WAAW,MAAM,MAAM,kBAAkB;EAC7C,QAAQ;EACR,SAAS,EAAE,gBAAgB,oCAAoC;EAC/D,MAAM,IAAI,gBAAgB;GACxB,YAAY;GACZ;GACA,cAAc;GACd,WAAW;GACX,eAAe;EACjB,CAAC;CACH,CAAC;CACD,IAAI,CAAC,SAAS,IAAI;EAEhB,MAAM,SAAS,MAAM,OAAO,CAAC,CAAC,YAAY,MAAS;EACnD,MAAM,IAAI,MAAM,8BAA8B,SAAS,QAAQ;CACjE;CAEA,MAAM,SAAU,MAAM,SAAS,KAAK;CAMpC,IAAI,CAAC,OAAO,YAAY,CAAC,OAAO,gBAAgB,CAAC,OAAO,eACtD,MAAM,IAAI,MAAM,uDAAuD;CAGzE,MAAM,WAAW,uBAAuB,OAAO,QAAQ;CACvD,MAAM,eAAe,uBAAuB,OAAO,YAAY;CAC/D,MAAM,YAAY,SAAS,aAAa,aAAa;CACrD,IAAI,CAAC,WAAW,MAAM,IAAI,MAAM,mDAAmD;CAEnF,OAAO;EACL,aAAa,OAAO;EACpB,cAAc,OAAO;EACrB,SAAS,OAAO;EAChB,sBACE,aAAa,cACZ,OAAO,aAAa,KAAK,IAAI,IAAI,OAAO,aAAa,MAAO,KAAK,IAAI;EACxE,GAAI,SAAS,YAAY,EAAE,kBAAkB,SAAS,UAAU,IAAI,CAAC;EACrE;EACA,GAAK,SAAS,YAAY,aAAa,WACnC,EAAE,UAAU,SAAS,YAAY,aAAa,SAAS,IACvD,CAAC;CACP;AACF"}

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

@@ -1,7 +1,77 @@
+import { buildCodexIdentityHeaders } from "./openai-backend-protocol.js";
 //#region src/utils/providers/openai/openai-quota.ts
-async function readOpenAIQuotaUsage(readRateLimits) {
+const CHATGPT_WHAM_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+async function readDirect(options) {
+	const response = await (options.fetch ?? fetch)(CHATGPT_WHAM_USAGE_URL, {
+		method: "GET",
+		headers: buildCodexIdentityHeaders(options.credentials.accessToken, options.credentials.accountId),
+		...options.signal ? { signal: options.signal } : {}
+	});
+	if (!response.ok) throw new Error(`OpenAI quota lookup failed: HTTP ${response.status}`);
+	return {
+		data: normalizeWhamUsage(await response.json()),
+		cachedAt: Date.now()
+	};
+}
+function windowFrom(value) {
+	if (!value || typeof value !== "object") return null;
+	const source = value;
+	const usedPercent = Number(source.usedPercent ?? source.used_percent);
+	if (!Number.isFinite(usedPercent)) return null;
+	const duration = source.windowDurationMins ?? source.window_minutes;
+	const resets = source.resetsAt ?? source.reset_at;
+	return {
+		usedPercent,
+		windowDurationMins: duration === null || duration === void 0 ? null : Number(duration),
+		resetsAt: resets === null || resets === void 0 ? null : Number(resets)
+	};
+}
+function snapshotFrom(value) {
+	const source = value && typeof value === "object" ? value : {};
+	const limitId = source.limitId ?? source.limit_id;
+	const limitName = source.limitName ?? source.limit_name;
+	return {
+		limitId: typeof limitId === "string" ? limitId : null,
+		limitName: typeof limitName === "string" ? limitName : null,
+		primary: windowFrom(source.primary ?? source.primary_window),
+		secondary: windowFrom(source.secondary ?? source.secondary_window),
+		credits: source.credits ?? null,
+		planType: typeof (source.planType ?? source.plan_type) === "string" ? String(source.planType ?? source.plan_type) : null,
+		rateLimitReachedType: typeof (source.rateLimitReachedType ?? source.rate_limit_reached) === "string" ? String(source.rateLimitReachedType ?? source.rate_limit_reached) : null
+	};
+}
+function normalizeWhamUsage(body) {
+	if (body.rateLimits && typeof body.rateLimits === "object") return body;
+	const container = body.rate_limits && typeof body.rate_limits === "object" ? body.rate_limits : body;
+	const shared = {
+		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
+	});
+	const additional = Array.isArray(container.additional_rate_limits) ? container.additional_rate_limits : Array.isArray(body.additional_rate_limits) ? body.additional_rate_limits : [];
+	const byId = {};
+	for (const entry of additional) {
+		if (!entry || typeof entry !== "object") continue;
+		const wrapper = entry;
+		const snapshot = snapshotFrom({
+			...shared,
+			...wrapper.rate_limit ?? wrapper
+		});
+		if (snapshot.limitId) byId[snapshot.limitId] = snapshot;
+	}
+	return {
+		rateLimits: primary,
+		rateLimitsByLimitId: Object.keys(byId).length ? byId : null
+	};
+}
+async function readOpenAIQuotaUsage(source) {
 	try {
-		const { data, cachedAt } = await readRateLimits();
+		const direct = typeof source !== "function";
+		const { data, cachedAt } = await (typeof source === "function" ? source() : readDirect(source));
 		const rateLimits = data.rateLimits;
 		const primary = rateLimits?.primary;
 		if (!primary || typeof primary.usedPercent !== "number" || !Number.isFinite(primary.usedPercent)) return {
@@ -14,7 +84,8 @@ async function readOpenAIQuotaUsage(readRateLimits) {
 			cacheAgeMs: Math.max(Date.now() - cachedAt, 0),
 			windowDurationMins: primary.windowDurationMins,
 			resetsAt: primary.resetsAt,
-			limitId: rateLimits.limitId
+			limitId: rateLimits.limitId,
+			...direct ? { raw: data } : {}
 		};
 	} catch (e) {
 		return {
@@ -24,6 +95,6 @@ async function readOpenAIQuotaUsage(readRateLimits) {
 	}
 }
 //#endregion
-export { readOpenAIQuotaUsage };
+export { CHATGPT_WHAM_USAGE_URL, readOpenAIQuotaUsage };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFpLXF1b3RhLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9wcm92aWRlcnMvb3BlbmFpL29wZW5haS1xdW90YS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIEdldEFjY291bnRSYXRlTGltaXRzUmVzcG9uc2UgfSBmcm9tIFwiLi4vLi4vLi4vY29kZXgtcHJvdG9jb2wvdjIvR2V0QWNjb3VudFJhdGVMaW1pdHNSZXNwb25zZVwiO1xuXG5leHBvcnQgdHlwZSBPcGVuQUlSYXRlTGltaXRzV2l0aE1ldGEgPSB7XG4gIGRhdGE6IEdldEFjY291bnRSYXRlTGltaXRzUmVzcG9uc2U7XG4gIGNhY2hlZEF0OiBudW1iZXI7XG59O1xuXG5leHBvcnQgdHlwZSBPcGVuQUlRdW90YVVzYWdlUmVzdWx0ID1cbiAgfCB7XG4gICAgICBraW5kOiBcIm9rXCI7XG4gICAgICB1dGlsaXphdGlvblBjdDogbnVtYmVyO1xuICAgICAgY2FjaGVBZ2VNczogbnVtYmVyO1xuICAgICAgd2luZG93RHVyYXRpb25NaW5zOiBudW1iZXIgfCBudWxsO1xuICAgICAgcmVzZXRzQXQ6IG51bWJlciB8IG51bGw7XG4gICAgICBsaW1pdElkOiBzdHJpbmcgfCBudWxsO1xuICAgIH1cbiAgfCB7IGtpbmQ6IFwibG9va3VwX2ZhaWxlZFwiOyByZWFzb246IHN0cmluZyB9O1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcmVhZE9wZW5BSVF1b3RhVXNhZ2UoXG4gIHJlYWRSYXRlTGltaXRzOiAoKSA9PiBQcm9taXNlPE9wZW5BSVJhdGVMaW1pdHNXaXRoTWV0YT4sXG4pOiBQcm9taXNlPE9wZW5BSVF1b3RhVXNhZ2VSZXN1bHQ+IHtcbiAgdHJ5IHtcbiAgICBjb25zdCB7IGRhdGEsIGNhY2hlZEF0IH0gPSBhd2FpdCByZWFkUmF0ZUxpbWl0cygpO1xuICAgIGNvbnN0IHJhdGVMaW1pdHMgPSBkYXRhLnJhdGVMaW1pdHM7XG4gICAgY29uc3QgcHJpbWFyeSA9IHJhdGVMaW1pdHM/LnByaW1hcnk7XG5cbiAgICBpZiAoXG4gICAgICAhcHJpbWFyeSB8fFxuICAgICAgdHlwZW9mIHByaW1hcnkudXNlZFBlcmNlbnQgIT09IFwibnVtYmVyXCIgfHxcbiAgICAgICFOdW1iZXIuaXNGaW5pdGUocHJpbWFyeS51c2VkUGVyY2VudClcbiAgICApIHtcbiAgICAgIHJldHVybiB7IGtpbmQ6IFwibG9va3VwX2ZhaWxlZFwiLCByZWFzb246IFwicHJpbWFyeSB1c2VkUGVyY2VudCB1bmF2YWlsYWJsZVwiIH07XG4gICAgfVxuXG4gICAgcmV0dXJuIHtcbiAgICAgIGtpbmQ6IFwib2tcIixcbiAgICAgIHV0aWxpemF0aW9uUGN0OiBwcmltYXJ5LnVzZWRQZXJjZW50LFxuICAgICAgY2FjaGVBZ2VNczogTWF0aC5tYXgoRGF0ZS5ub3coKSAtIGNhY2hlZEF0LCAwKSxcbiAgICAgIHdpbmRvd0R1cmF0aW9uTWluczogcHJpbWFyeS53aW5kb3dEdXJhdGlvbk1pbnMsXG4gICAgICByZXNldHNBdDogcHJpbWFyeS5yZXNldHNBdCxcbiAgICAgIGxpbWl0SWQ6IHJhdGVMaW1pdHMubGltaXRJZCxcbiAgICB9O1xuICB9IGNhdGNoIChlKSB7XG4gICAgcmV0dXJuIHsga2luZDogXCJsb29rdXBfZmFpbGVkXCIsIHJlYXNvbjogKGUgYXMgRXJyb3IpLm1lc3NhZ2UgfTtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiO0FBa0JBLGVBQXNCLHFCQUNwQixnQkFDaUM7Q0FDakMsSUFBSTtFQUNGLE1BQU0sRUFBRSxNQUFNLGFBQWEsTUFBTSxlQUFlO0VBQ2hELE1BQU0sYUFBYSxLQUFLO0VBQ3hCLE1BQU0sVUFBVSxZQUFZO0VBRTVCLElBQ0UsQ0FBQyxXQUNELE9BQU8sUUFBUSxnQkFBZ0IsWUFDL0IsQ0FBQyxPQUFPLFNBQVMsUUFBUSxXQUFXLEdBRXBDLE9BQU87R0FBRSxNQUFNO0dBQWlCLFFBQVE7RUFBa0M7RUFHNUUsT0FBTztHQUNMLE1BQU07R0FDTixnQkFBZ0IsUUFBUTtHQUN4QixZQUFZLEtBQUssSUFBSSxLQUFLLElBQUksSUFBSSxVQUFVLENBQUM7R0FDN0Msb0JBQW9CLFFBQVE7R0FDNUIsVUFBVSxRQUFRO0dBQ2xCLFNBQVMsV0FBVztFQUN0QjtDQUNGLFNBQVMsR0FBRztFQUNWLE9BQU87R0FBRSxNQUFNO0dBQWlCLFFBQVMsRUFBWTtFQUFRO0NBQy9EO0FBQ0YifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-quota.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-quota.ts"],"sourcesContent":["import { type OpenAICredentials } from \"../../../application/token/token.types\";\nimport { type QuotaRateLimits, type QuotaRateLimitSnapshot } from \"../common/provider-types\";\nimport { buildCodexIdentityHeaders } from \"./openai-backend-protocol\";\n\nexport const CHATGPT_WHAM_USAGE_URL = \"https://chatgpt.com/backend-api/wham/usage\" as const;\n\nexport type OpenAIRateLimitsWithMeta = {\n  data: QuotaRateLimits;\n  cachedAt: number;\n};\n\nexport type OpenAIQuotaUsageResult =\n  | {\n      kind: \"ok\";\n      utilizationPct: number;\n      cacheAgeMs: number;\n      windowDurationMins: number | null;\n      resetsAt: number | null;\n      limitId: string | null;\n      raw?: QuotaRateLimits;\n    }\n  | { kind: \"lookup_failed\"; reason: string };\n\nexport interface OpenAIQuotaHttpOptions {\n  credentials: Pick<OpenAICredentials, \"accessToken\" | \"accountId\">;\n  fetch?: typeof fetch;\n  signal?: AbortSignal;\n}\n\nasync function readDirect(options: OpenAIQuotaHttpOptions): Promise<OpenAIRateLimitsWithMeta> {\n  const response = await (options.fetch ?? fetch)(CHATGPT_WHAM_USAGE_URL, {\n    method: \"GET\",\n    headers: buildCodexIdentityHeaders(\n      options.credentials.accessToken,\n      options.credentials.accountId,\n    ),\n    ...(options.signal ? { signal: options.signal } : {}),\n  });\n  if (!response.ok) throw new Error(`OpenAI quota lookup failed: HTTP ${response.status}`);\n  const body = (await response.json()) as Record<string, unknown>;\n  const data = normalizeWhamUsage(body);\n  return { data, cachedAt: Date.now() };\n}\n\nfunction windowFrom(value: unknown) {\n  if (!value || typeof value !== \"object\") return null;\n  const source = value as Record<string, unknown>;\n  const usedPercent = Number(source.usedPercent ?? source.used_percent);\n  if (!Number.isFinite(usedPercent)) return null;\n  const duration = source.windowDurationMins ?? source.window_minutes;\n  const resets = source.resetsAt ?? source.reset_at;\n  return {\n    usedPercent,\n    windowDurationMins: duration === null || duration === undefined ? null : Number(duration),\n    resetsAt: resets === null || resets === undefined ? null : Number(resets),\n  };\n}\n\nfunction snapshotFrom(value: unknown): QuotaRateLimitSnapshot {\n  const source = (value && typeof value === \"object\" ? value : {}) as Record<string, unknown>;\n  const limitId = source.limitId ?? source.limit_id;\n  const limitName = source.limitName ?? source.limit_name;\n  return {\n    limitId: typeof limitId === \"string\" ? limitId : null,\n    limitName: typeof limitName === \"string\" ? limitName : null,\n    primary: windowFrom(source.primary ?? source.primary_window),\n    secondary: windowFrom(source.secondary ?? source.secondary_window),\n    credits: (source.credits ?? null) as QuotaRateLimitSnapshot[\"credits\"],\n    planType:\n      typeof (source.planType ?? source.plan_type) === \"string\"\n        ? String(source.planType ?? source.plan_type)\n        : null,\n    rateLimitReachedType:\n      typeof (source.rateLimitReachedType ?? source.rate_limit_reached) === \"string\"\n        ? String(source.rateLimitReachedType ?? source.rate_limit_reached)\n        : null,\n  };\n}\n\nfunction normalizeWhamUsage(body: Record<string, unknown>): QuotaRateLimits {\n  if (body.rateLimits && typeof body.rateLimits === \"object\") {\n    return body as QuotaRateLimits;\n  }\n  const container =\n    body.rate_limits && typeof body.rate_limits === \"object\"\n      ? (body.rate_limits as Record<string, unknown>)\n      : body;\n  const shared = {\n    plan_type: body.plan_type ?? container.plan_type,\n    credits: body.credits ?? container.credits,\n    rate_limit_reached: body.rate_limit_reached ?? container.rate_limit_reached,\n  };\n  const primary = snapshotFrom({\n    ...shared,\n    ...((container.rate_limit ?? container) as Record<string, unknown>),\n  });\n  const additional = Array.isArray(container.additional_rate_limits)\n    ? container.additional_rate_limits\n    : Array.isArray(body.additional_rate_limits)\n      ? body.additional_rate_limits\n      : [];\n  const byId: Record<string, QuotaRateLimitSnapshot> = {};\n  for (const entry of additional) {\n    if (!entry || typeof entry !== \"object\") continue;\n    const wrapper = entry as Record<string, unknown>;\n    const snapshot = snapshotFrom({\n      ...shared,\n      ...((wrapper.rate_limit ?? wrapper) as Record<string, unknown>),\n    });\n    if (snapshot.limitId) byId[snapshot.limitId] = snapshot;\n  }\n  return {\n    rateLimits: primary,\n    rateLimitsByLimitId: Object.keys(byId).length ? byId : null,\n  };\n}\n\nexport async function readOpenAIQuotaUsage(\n  source: (() => Promise<OpenAIRateLimitsWithMeta>) | OpenAIQuotaHttpOptions,\n): Promise<OpenAIQuotaUsageResult> {\n  try {\n    const direct = typeof source !== \"function\";\n    const { data, cachedAt } = await (typeof source === \"function\" ? source() : readDirect(source));\n    const rateLimits = data.rateLimits;\n    const primary = rateLimits?.primary;\n\n    if (\n      !primary ||\n      typeof primary.usedPercent !== \"number\" ||\n      !Number.isFinite(primary.usedPercent)\n    ) {\n      return { kind: \"lookup_failed\", reason: \"primary usedPercent unavailable\" };\n    }\n\n    return {\n      kind: \"ok\",\n      utilizationPct: primary.usedPercent,\n      cacheAgeMs: Math.max(Date.now() - cachedAt, 0),\n      windowDurationMins: primary.windowDurationMins,\n      resetsAt: primary.resetsAt,\n      limitId: rateLimits.limitId,\n      ...(direct ? { raw: data } : {}),\n    };\n  } catch (e) {\n    return { kind: \"lookup_failed\", reason: (e as Error).message };\n  }\n}\n"],"mappings":"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"}

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

@@ -1,12 +1,12 @@
 import { TokenModel } from "../../../application/token/token.model.js";
-import { deactivateAuthDeadToken } from "../../../application/qgrid/token-death.js";
 import { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from "./openai-constants.js";
+import { deactivateAuthDeadToken } from "../../../application/qgrid/token-death.js";
 import { getLogger } from "@logtape/logtape";
 //#region src/utils/providers/openai/openai-refresh.ts
 /**
 * OpenAI chatgptAuthTokens refresh handler.
 *
-* - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄
+* - direct HTTPS/WS transport가 401 refresh를 소유하고 저장된 refresh token으로 갱신함
 * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답
 * - per-token inflight promise 로 concurrent refresh dedup
 * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트
@@ -112,4 +112,4 @@ async function doRefresh(tokenId) {
 //#endregion
 export { handleChatgptAuthTokensRefresh };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { deactivateAuthDeadToken } from \"../../../application/qgrid/token-death\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// 재로그인 외 복구 불가한 refresh 실패 코드. 어느 것이든 토큰이 죽었다는 확정 신호다.\nconst PERMANENT_FAILURE_CODES = new Set([\n  \"refresh_token_expired\",\n  \"refresh_token_reused\",\n  \"refresh_token_invalidated\",\n]);\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가\n    // 상태코드를 바꿀 때 판정이 조용히 멎는다.\n    if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {\n      await deactivateAuthDeadToken(\n        { id: tokenId, name: token.name, provider: \"openai\" },\n        creds.refreshToken,\n        `openai:${errorCode}`,\n      );\n    }\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - direct HTTPS/WS transport가 401 refresh를 소유하고 저장된 refresh token으로 갱신함\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { deactivateAuthDeadToken } from \"../../../application/qgrid/token-death\";\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// 재로그인 외 복구 불가한 refresh 실패 코드. 어느 것이든 토큰이 죽었다는 확정 신호다.\nconst PERMANENT_FAILURE_CODES = new Set([\n  \"refresh_token_expired\",\n  \"refresh_token_reused\",\n  \"refresh_token_invalidated\",\n]);\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    // 토큰 엔드포인트는 OAuth 표준 form 인코딩 계약을 강제한다. JSON 으로 보내면\n    // access token 만료 후의 모든 refresh 가 거부되어 토큰이 통째로 죽는다.\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    // 영구 실패는 errorCode 로만 판정한다 — status 를 함께 요구하면 provider 가\n    // 상태코드를 바꿀 때 판정이 조용히 멎는다.\n    if (errorCode && PERMANENT_FAILURE_CODES.has(errorCode)) {\n      await deactivateAuthDeadToken(\n        { id: tokenId, name: token.name, provider: \"openai\" },\n        creds.refreshToken,\n        `openai:${errorCode}`,\n      );\n    }\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,72 @@
+import { OpenAIProtocolError, normalizeOpenAIEvent } from "./openai-backend-protocol.js";
+//#region src/utils/providers/openai/openai-sse.ts
+function parseBlock(block) {
+	const data = [];
+	for (const line of block.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n")) {
+		if (line.startsWith(":")) continue;
+		const separator = line.indexOf(":");
+		const field = separator < 0 ? line : line.slice(0, separator);
+		let value = separator < 0 ? "" : line.slice(separator + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "data") data.push(value);
+	}
+	if (!data.length) return void 0;
+	const payload = data.join("\n");
+	if (payload === "[DONE]") return payload;
+	try {
+		return JSON.parse(payload);
+	} catch (error) {
+		throw new OpenAIProtocolError(`Invalid OpenAI SSE JSON: ${String(error)}`);
+	}
+}
+/** Parses arbitrary UTF-8/chunk boundaries and all complete SSE event blocks. */
+async function* parseOpenAISSE(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			buffer += decoder.decode(value, { stream: !done });
+			let match;
+			while (match = /\r\n\r\n|\n\n|\r\r/.exec(buffer)) {
+				const block = buffer.slice(0, match.index);
+				buffer = buffer.slice(match.index + match[0].length);
+				const parsed = parseBlock(block);
+				if (parsed !== void 0) yield parsed;
+			}
+			if (done) break;
+		}
+		if (buffer.trim()) {
+			const parsed = parseBlock(buffer);
+			if (parsed !== void 0) yield parsed;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+/** Converts wire events and enforces exactly one successful terminal response. */
+async function* normalizeOpenAISSE(body) {
+	let terminal = false;
+	for await (const raw of parseOpenAISSE(body)) {
+		if (raw === "[DONE]") {
+			if (!terminal) throw new OpenAIProtocolError("OpenAI stream ended before response.completed");
+			return;
+		}
+		if (terminal) throw new OpenAIProtocolError("OpenAI stream emitted an event after termination");
+		const event = normalizeOpenAIEvent(raw);
+		if (!event) continue;
+		if (event.type === "error") {
+			terminal = true;
+			yield event;
+			return;
+		}
+		if (event.type === "completed") terminal = true;
+		yield event;
+	}
+	if (!terminal) throw new OpenAIProtocolError("OpenAI SSE connection closed before a terminal event");
+}
+//#endregion
+export { normalizeOpenAISSE, parseOpenAISSE };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/utils/providers/openai/openai-transport-config.js

@@ -0,0 +1,14 @@
+//#region src/utils/providers/openai/openai-transport-config.ts
+/**
+* OpenAI 전송 방식 선택. 동시성 knob 은 없다 — direct 전환으로 요청은 Anthropic 과
+* 동일하게 상한 없이 나가며, 상류 제한은 백엔드 응답이 진실이다.
+*/
+function resolveOpenAITransportKind(env = process.env) {
+	const transport = env.QGRID_OPENAI_TRANSPORT ?? "websocket";
+	if (transport !== "https" && transport !== "websocket") throw new Error(`Invalid QGRID_OPENAI_TRANSPORT value: ${transport}. Expected https or websocket.`);
+	return transport;
+}
+//#endregion
+export { resolveOpenAITransportKind };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFpLXRyYW5zcG9ydC1jb25maWcuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL3Byb3ZpZGVycy9vcGVuYWkvb3BlbmFpLXRyYW5zcG9ydC1jb25maWcudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgT3BlbkFJVHJhbnNwb3J0S2luZCA9IFwiaHR0cHNcIiB8IFwid2Vic29ja2V0XCI7XG5cbi8qKlxuICogT3BlbkFJIOyghOyGoSDrsKnsi50g7ISg7YOdLiDrj5nsi5zshLEga25vYiDsnYAg7JeG64ukIOKAlCBkaXJlY3Qg7KCE7ZmY7Jy866GcIOyalOyyreydgCBBbnRocm9waWMg6rO8XG4gKiDrj5nsnbztlZjqsowg7IOB7ZWcIOyXhuydtCDrgpjqsIDrqbAsIOyDgeulmCDsoJztlZzsnYAg67Cx7JeU65OcIOydkeuLteydtCDsp4Tsi6TsnbTri6QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZXNvbHZlT3BlbkFJVHJhbnNwb3J0S2luZChcbiAgZW52OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCB1bmRlZmluZWQ+ID0gcHJvY2Vzcy5lbnYsXG4pOiBPcGVuQUlUcmFuc3BvcnRLaW5kIHtcbiAgY29uc3QgdHJhbnNwb3J0ID0gZW52LlFHUklEX09QRU5BSV9UUkFOU1BPUlQgPz8gXCJ3ZWJzb2NrZXRcIjtcbiAgaWYgKHRyYW5zcG9ydCAhPT0gXCJodHRwc1wiICYmIHRyYW5zcG9ydCAhPT0gXCJ3ZWJzb2NrZXRcIikge1xuICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgIGBJbnZhbGlkIFFHUklEX09QRU5BSV9UUkFOU1BPUlQgdmFsdWU6ICR7dHJhbnNwb3J0fS4gRXhwZWN0ZWQgaHR0cHMgb3Igd2Vic29ja2V0LmAsXG4gICAgKTtcbiAgfVxuICByZXR1cm4gdHJhbnNwb3J0O1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7OztBQU1BLFNBQWdCLDJCQUNkLE1BQTBDLFFBQVEsS0FDN0I7Q0FDckIsTUFBTSxZQUFZLElBQUksMEJBQTBCO0NBQ2hELElBQUksY0FBYyxXQUFXLGNBQWMsYUFDekMsTUFBTSxJQUFJLE1BQ1IseUNBQXlDLFVBQVUsK0JBQ3JEO0NBRUYsT0FBTztBQUNUIn0=

package/bundle/src/application/monit/monit.frame.test.ts

@@ -114,30 +114,28 @@ describe("MonitFrame.monitLogs", () => {
 
   it("piggybacks live vitals on every chunk, zeroed before dispatchers boot", async () => {
     QgridDispatcher.openaiDispatcher = {
-      workerCount: 25,
-      readyWorkerCount: 24,
-      queueLength: 3,
-      workerCountsByToken: [
-        { name: "openai/haze", count: 12 },
-        { name: "openai/nk", count: 13 },
+      inFlight: 3,
+      quotaByToken: [
+        { name: "openai/haze", usedPercent: 41, threshold: 80, blocked: false, resetsAt: null },
+        { name: "openai/nk", usedPercent: null, threshold: null, blocked: false, resetsAt: null },
       ],
     } as never;
     QgridDispatcher.anthropicDispatcher = {
       tokenCount: 8,
       tokenNames: ["anthropic/haze", "anthropic/noa"],
+      inFlight: 2,
     } as never;
     try {
       const chunk = await MonitFrame.monitLogs();
       expect(chunk.vitals).toEqual({
-        openaiWorkerCount: 25,
-        openaiReadyWorkerCount: 24,
-        openaiQueueLength: 3,
-        openaiWorkersByToken: [
-          { name: "openai/haze", count: 12 },
-          { name: "openai/nk", count: 13 },
+        openaiInFlight: 3,
+        openaiQuotaByToken: [
+          { name: "openai/haze", usedPercent: 41, threshold: 80, blocked: false, resetsAt: null },
+          { name: "openai/nk", usedPercent: null, threshold: null, blocked: false, resetsAt: null },
         ],
         anthropicTokenCount: 8,
         anthropicTokenNames: ["anthropic/haze", "anthropic/noa"],
+        anthropicInFlight: 2,
       });
     } finally {
       QgridDispatcher.openaiDispatcher = null;
@@ -145,15 +143,15 @@ describe("MonitFrame.monitLogs", () => {
     }
 
     const empty = await MonitFrame.monitLogs();
-    expect(empty.vitals.openaiWorkerCount).toBe(0);
-    expect(empty.vitals.openaiWorkersByToken).toEqual([]);
+    expect(empty.vitals.openaiInFlight).toBe(0);
+    expect(empty.vitals.openaiQuotaByToken).toEqual([]);
     expect(empty.vitals.anthropicTokenCount).toBe(0);
     expect(empty.vitals.anthropicTokenNames).toEqual([]);
   });
 });
 
 describe("MonitFrame.monitInfo", () => {
-  it("returns the active DB connection, server url, and pool bounds without secrets", async () => {
+  it("returns the active DB connection, server url, and permit capacity without secrets", async () => {
     vi.stubEnv("HOST", "0.0.0.0");
     vi.stubEnv("PORT", "45000");
     vi.stubEnv("SONAMU_DB_HOST", "db.internal");
@@ -165,8 +163,7 @@ describe("MonitFrame.monitInfo", () => {
     expect(info.serverUrl).toBe("http://0.0.0.0:45000");
     expect(info.dbHost).toBe("db.internal");
     expect(info.dbName).toBe("qgrid_dev");
-    expect(info.openai.minWorkersPerToken).toBeGreaterThan(0);
-    expect(info.openai.maxWorkersPerToken).toBeGreaterThanOrEqual(info.openai.minWorkersPerToken);
+    expect(["https", "websocket"]).toContain(info.openai.transport);
     // allowlist — 연결 객체의 password/user 등은 절대 실리지 않는다.
     expect(Object.keys(info).toSorted()).toEqual(["dbHost", "dbName", "openai", "serverUrl"]);
     expect(JSON.stringify(info)).not.toContain("password");

package/bundle/src/application/monit/monit.frame.ts

@@ -6,10 +6,16 @@
  */
 import { api, BaseFrameClass, DB } from "sonamu";
 
-import { resolveOpenAIWorkerPoolConfig } from "../../utils/providers/openai/openai-worker-pool-config";
+import { resolveOpenAITransportKind } from "../../utils/providers/openai/openai-transport-config";
 import { QgridDispatcher } from "../qgrid/qgrid.dispatcher";
+import { RequestLogModel } from "../request-log/request-log.model";
 import { monitLogBuffer } from "./log-buffer";
-import { type MonitLogChunk, type MonitServerInfo, type MonitVitals } from "./monit.types";
+import {
+  type MonitLogChunk,
+  type MonitServerInfo,
+  type MonitStats,
+  type MonitVitals,
+} from "./monit.types";
 
 // 응답당 엔트리 상한 — 폴링 클라이언트는 다음 폴에서 이어서 따라잡는다.
 const RESPONSE_ENTRY_LIMIT = 1_000;
@@ -31,7 +37,7 @@ class MonitFrameClass extends BaseFrameClass {
   // 프로세스 정적 정보 — 폴링 불필요, 페이지당 1회 조회.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
   async monitInfo(): Promise<MonitServerInfo> {
-    const pool = resolveOpenAIWorkerPoolConfig();
+    const transport = resolveOpenAITransportKind();
     const host = process.env.HOST ?? "localhost";
     const port = process.env.PORT ?? "44900";
     const conn = activeDbConnection();
@@ -39,24 +45,29 @@ class MonitFrameClass extends BaseFrameClass {
       serverUrl: `http://${host}:${port}`,
       dbHost: conn.host ?? "localhost",
       dbName: conn.database ?? "qgrid",
-      openai: {
-        minWorkersPerToken: pool.minWorkersPerToken,
-        maxWorkersPerToken: pool.maxWorkersPerToken,
-        autoscale: pool.autoscale,
-      },
+      openai: { transport },
     };
   }
+
+  // 최근 1시간 provider 별 요청/오류/캐시 통계. vitals 와 달리 request_logs 를 타므로
+  // 분리된 endpoint 로 두고 웹에서 더 느슨한 주기로 폴링한다. 읽기 전용이며 request log 를
+  // 남기지 않는 monit 경계는 동일하다.
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async monitStats(): Promise<MonitStats> {
+    const windowMinutes = 60;
+    const since = new Date(Date.now() - windowMinutes * 60_000);
+    return { windowMinutes, providers: await RequestLogModel.providerStatsSince(since) };
+  }
 }
 
 // dispatcher 미초기화(부팅 직후) 시 0 으로 응답한다 — 가벼운 스냅샷이라 오류로 만들지 않는다.
 function currentVitals(): MonitVitals {
   return {
-    openaiWorkerCount: QgridDispatcher.openaiDispatcher?.workerCount ?? 0,
-    openaiReadyWorkerCount: QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0,
-    openaiQueueLength: QgridDispatcher.openaiDispatcher?.queueLength ?? 0,
-    openaiWorkersByToken: QgridDispatcher.openaiDispatcher?.workerCountsByToken ?? [],
+    openaiInFlight: QgridDispatcher.openaiDispatcher?.inFlight ?? 0,
+    openaiQuotaByToken: QgridDispatcher.openaiDispatcher?.quotaByToken ?? [],
     anthropicTokenCount: QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0,
     anthropicTokenNames: QgridDispatcher.anthropicDispatcher?.tokenNames ?? [],
+    anthropicInFlight: QgridDispatcher.anthropicDispatcher?.inFlight ?? 0,
   };
 }
 

package/bundle/src/application/monit/monit.types.ts

@@ -15,17 +15,30 @@ export const MonitLogEntry = z.object({
 });
 export type MonitLogEntry = z.infer<typeof MonitLogEntry>;
 
-// 폴링에 편승하는 라이브 카운트 — 깊은 워커/큐 진단은 audit 대시보드(별도)의 몫이고,
-// 여기는 "지금 몇 개 돌고 큐가 쌓이나"만 가볍게 답한다.
+// 폴링에 편승하는 라이브 카운트 — 깊은 토큰 진단은 audit 대시보드(별도)의 몫이고,
+// 여기는 "지금 요청이 몇 개 나가 있고 쿼터가 얼마나 찼나"만 가볍게 답한다.
 export const MonitVitals = z.object({
-  openaiWorkerCount: z.number(),
-  openaiReadyWorkerCount: z.number(),
-  openaiQueueLength: z.number(),
-  // 토큰별 현재 워커 수 — autoscale 로 늘고 주는 것을 토큰 단위로 본다
-  openaiWorkersByToken: z.array(z.object({ name: z.string(), count: z.number() })),
+  // 지금 나가 있는 동시 요청 수 — 상한 없음(Anthropic 과 동일한 stateless 실행 모델).
+  // 토큰별 숫자는 노출하지 않는다: Anthropic 칩과 동일하게 이름 나열이 기본이고,
+  // 토큰 단위로 의미 있는 상태는 쿼터 스냅샷이 맡는다.
+  openaiInFlight: z.number(),
+  // 토큰별 쿼터 스냅샷 — dispatcher 의 60초 rate-limits 캐시에서만 읽는다(비신선이면 null).
+  // threshold 미설정 토큰은 쿼터 판정을 돌지 않아 usedPercent 가 계속 null 일 수 있다.
+  openaiQuotaByToken: z.array(
+    z.object({
+      name: z.string(),
+      usedPercent: z.number().nullable(),
+      threshold: z.number().nullable(),
+      blocked: z.boolean(),
+      // ms epoch — dispatcher 가 wham 의 unix 초를 정규화해서 내려준다
+      resetsAt: z.number().nullable(),
+    }),
+  ),
   anthropicTokenCount: z.number(),
-  // fresh-spawn 이라 워커 수는 없다 — 풀에 어떤 토큰이 있는지만 보여준다
+  // fresh-spawn 이라 상주 프로세스가 없다 — 풀에 어떤 토큰이 있는지만 보여준다
   anthropicTokenNames: z.array(z.string()),
+  // 지금 실행 중인 Claude Code 프로세스 수
+  anthropicInFlight: z.number(),
 });
 export type MonitVitals = z.infer<typeof MonitVitals>;
 
@@ -45,10 +58,26 @@ export const MonitServerInfo = z.object({
   serverUrl: z.string(),
   dbHost: z.string(),
   dbName: z.string(),
+  // permit/큐 제거 후 남은 정적 설정은 전송 방식뿐이다. 동시성 상한은 없다.
   openai: z.object({
-    minWorkersPerToken: z.number(),
-    maxWorkersPerToken: z.number(),
-    autoscale: z.boolean(),
+    transport: z.string(),
   }),
 });
 export type MonitServerInfo = z.infer<typeof MonitServerInfo>;
+
+// 최근 1시간 provider 별 요청 통계 — request_logs 를 집계한다. vitals 와 달리 DB 를
+// 타므로 별도 endpoint 로 분리해 더 느슨한 주기로 폴링한다.
+export const MonitProviderStats = z.object({
+  provider: z.string(), // "openai" | "anthropic" | "unknown"
+  requests: z.number(),
+  errors: z.number(),
+  inputTokens: z.number(),
+  cacheReadTokens: z.number(),
+});
+export type MonitProviderStats = z.infer<typeof MonitProviderStats>;
+
+export const MonitStats = z.object({
+  windowMinutes: z.number(),
+  providers: z.array(MonitProviderStats),
+});
+export type MonitStats = z.infer<typeof MonitStats>;