@opengeni/codex 0.2.0

package/src/normalize.ts

@@ -0,0 +1,132 @@
+// Pure request-body + model-slug transforms for the ChatGPT/Codex backend.
+//
+// Per the verified NORMALIZATION VERDICT (CODEX-IMPL-PACKET §0), against our
+// @openai/agents stack we do EXACTLY this and no more:
+//   - force store:false
+//   - union include with reasoning.encrypted_content
+//   - strip max_output_tokens / max_completion_tokens
+//   - reasoning effort minimal -> low
+//   - normalize the model slug (longest-prefix against the live catalog)
+//   - strip every item `id` but PRESERVE `call_id`
+// We do NOT filter item_reference (the SDK never emits it) and do NOT convert
+// orphaned tool outputs (the SDK's runner already prunes by call_id).
+
+const MINIMAL = "minimal";
+
+// The ChatGPT/Codex backend is a STRICT ALLOWLIST: it 400s on ANY top-level field
+// the Codex CLI itself does not send (confirmed live against the backend —
+// "Unsupported parameter: temperature / top_p / metadata / previous_response_id /
+// logprobs / service_tier / user / safety_identifier / truncation / max_tool_calls /
+// background / conversation", and "Unsupported tool type: mcp"). Our @openai/agents
+// stack adds several of these, so after our transforms we keep ONLY the codex
+// Responses payload fields (CODEX-SUBSCRIPTION-SPEC §1 field table).
+const CODEX_ALLOWED_TOP_LEVEL_KEYS = new Set<string>([
+  "model",
+  "instructions",
+  "input",
+  "tools",
+  "tool_choice",
+  "parallel_tool_calls",
+  "reasoning",
+  "store",
+  "stream",
+  "include",
+  "prompt_cache_key",
+  "text",
+]);
+
+/** Mutates a parsed Responses request body in place and returns it. Pure + synchronous + unit-testable. */
+export function normalizeCodexRequestBody(
+  body: Record<string, unknown>,
+  resolveModel: (slug: string) => string,
+): Record<string, unknown> {
+  body.store = false; // ChatGPT backend REQUIRES store=false (spec §1.3)
+  body.stream = true; // ChatGPT backend REQUIRES stream=true (confirmed live: 400 "Stream must be set to true").
+
+  // include MUST contain reasoning.encrypted_content (stateless continuity, spec §1.6)
+  const include = Array.isArray(body.include) ? (body.include as unknown[]).filter((v): v is string => typeof v === "string") : [];
+  if (!include.includes("reasoning.encrypted_content")) {
+    include.push("reasoning.encrypted_content");
+  }
+  body.include = include;
+
+  // reasoning effort: minimal -> low (backend rejects minimal). spec §1.5
+  const reasoning = body.reasoning as { effort?: string } | null | undefined;
+  if (reasoning && reasoning.effort === MINIMAL) {
+    reasoning.effort = "low";
+  }
+
+  // model slug: longest-prefix against the live catalog. spec §1.4
+  if (typeof body.model === "string") {
+    body.model = resolveModel(body.model);
+  }
+
+  // strip every item id; PRESERVE call_id. spec §1.6 / verdict §0(b)
+  // (This also covers tool_search items: the backend accepts an id-less
+  // tool_search_call/output pair correlated by call_id — verified live — and
+  // stripping the account-bound `tsc_…` id here sanitizes BOTH replay paths.)
+  if (Array.isArray(body.input)) {
+    for (const item of body.input as unknown[]) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      const record = item as Record<string, unknown>;
+      if ("id" in record) {
+        delete record.id;
+      }
+      // A replayed tool_search_call must carry `arguments` as an OBJECT — the
+      // backend 400s a string ("Invalid type for 'input[N].arguments': expected
+      // an object", verified live). The live wire emits an object (the SDK's
+      // protocol schema is z.unknown() and round-trips it), so this only fires
+      // for a defensively-stringified row; unparseable strings fall back to {}.
+      if (record.type === "tool_search_call" && typeof record.arguments === "string") {
+        try {
+          const parsed = JSON.parse(record.arguments) as unknown;
+          record.arguments = parsed && typeof parsed === "object" ? parsed : {};
+        } catch {
+          record.arguments = {};
+        }
+      }
+    }
+  }
+
+  // Drop hosted-MCP tool entries: the backend rejects them ("Unsupported tool
+  // type: mcp"). OpenGeni's MCP servers are client-connected, so their tools
+  // already arrive as `function` tools — this only sheds a stray `mcp` entry.
+  if (Array.isArray(body.tools)) {
+    body.tools = (body.tools as unknown[]).filter(
+      (t) => !(t && typeof t === "object" && (t as Record<string, unknown>).type === "mcp"),
+    );
+  }
+
+  // Final allowlist: shed every other top-level field our @openai/agents stack
+  // may have added (temperature, top_p, metadata, previous_response_id,
+  // max_output_tokens, truncation, …) so the strict backend does not 400.
+  for (const key of Object.keys(body)) {
+    if (!CODEX_ALLOWED_TOP_LEVEL_KEYS.has(key)) {
+      delete body[key];
+    }
+  }
+  return body;
+}
+
+/**
+ * Build a longest-prefix model resolver. Catalog slugs come from GET /models
+ * (api-client.ts). One leading `namespace/` segment is stripped first; an
+ * unknown slug returns the fallback (caller should log — spec §1.4 step 4).
+ */
+export function buildModelResolver(
+  liveSlugs: readonly string[],
+  fallbackSlug: string,
+): (slug: string) => string {
+  return (requested: string): string => {
+    const stripped = requested.includes("/") ? requested.slice(requested.indexOf("/") + 1) : requested;
+    let best = "";
+    for (const slug of liveSlugs) {
+      if (stripped.startsWith(slug) && slug.length > best.length) {
+        best = slug;
+      }
+    }
+    return best || fallbackSlug;
+  };
+}

package/src/refresh.ts

@@ -0,0 +1,124 @@
+// Token refresh + JWT helpers + permanent-failure classification.
+// Refresh is JSON-bodied (exchange is form-encoded — spec §1.1 contrasts these).
+// Classification mirrors codex-rs manager.rs:180-184.
+
+import { CODEX_CLIENT_ID, CODEX_ID_TOKEN_AUTH_CLAIM, CODEX_TOKEN_URL } from "./constants";
+import type { CodexFetch } from "./device-code";
+
+/** Permanent — the workspace must reconnect (status => needs_relogin). */
+export class CodexReloginRequired extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CodexReloginRequired";
+  }
+}
+
+/** Transient — safe to retry later. */
+export class CodexRefreshTransient extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CodexRefreshTransient";
+  }
+}
+
+/** Only present fields are returned (the server may rotate any subset). */
+export type CodexRefreshTokens = {
+  idToken?: string | undefined;
+  accessToken?: string | undefined;
+  refreshToken?: string | undefined;
+};
+
+/** POST {issuer}/oauth/token JSON {client_id, grant_type:"refresh_token", refresh_token}. manager.rs:1336-1340 */
+export async function refreshCodexToken(
+  refreshToken: string,
+  fetchImpl: CodexFetch = fetch,
+): Promise<CodexRefreshTokens> {
+  const res = await fetchImpl(CODEX_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CODEX_CLIENT_ID, grant_type: "refresh_token", refresh_token: refreshToken }),
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    const code = extractRefreshErrorCode(text);
+    const msg = code ? PERMANENT_REFRESH_FAILURES[code] : undefined;
+    if (msg) {
+      throw new CodexReloginRequired(msg);
+    }
+    if (res.status === 401) {
+      throw new CodexReloginRequired("Your Codex session could not be refreshed. Please disconnect and sign in again.");
+    }
+    throw new CodexRefreshTransient(`Failed to refresh Codex token: ${res.status}`);
+  }
+  const body = JSON.parse(text) as { id_token?: string; access_token?: string; refresh_token?: string };
+  return { idToken: body.id_token, accessToken: body.access_token, refreshToken: body.refresh_token };
+}
+
+// Codes that mean the refresh token is permanently dead -> reconnect required.
+// Includes the standard OAuth `invalid_grant` alongside the Codex-specific codes.
+const PERMANENT_REFRESH_FAILURES: Record<string, string> = {
+  refresh_token_expired: "Your Codex refresh token has expired. Please disconnect and sign in again.",
+  refresh_token_reused: "Your Codex refresh token was already used. Please disconnect and sign in again.",
+  refresh_token_invalidated: "Your Codex refresh token was revoked. Please disconnect and sign in again.",
+  invalid_grant: "Your Codex session is no longer valid. Please disconnect and sign in again.",
+};
+
+/** Pull an error code from any of the shapes the auth server may return. */
+function extractRefreshErrorCode(text: string): string | undefined {
+  try {
+    const o = JSON.parse(text) as Record<string, unknown>;
+    const err = o.error;
+    if (typeof err === "string") {
+      return err; // { "error": "invalid_grant" }
+    }
+    if (err && typeof err === "object") {
+      const e = err as Record<string, unknown>;
+      if (typeof e.code === "string") return e.code; // { "error": { "code": "..." } }
+      if (typeof e.type === "string") return e.type;
+    }
+    if (typeof o.code === "string") return o.code; // { "code": "..." }
+    if (typeof o.type === "string") return o.type;
+  } catch {
+    /* not JSON */
+  }
+  return undefined;
+}
+
+/** Decode a JWT payload (base64url, no signature check). */
+export function decodeJwtPayload(jwt: string): Record<string, unknown> | null {
+  const part = jwt.split(".")[1];
+  if (!part) {
+    return null;
+  }
+  try {
+    const json = Buffer.from(part.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+    return JSON.parse(json) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+/** access-token `exp` claim -> Date | null. token_data.rs:101-105 */
+export function accessTokenExpiry(accessToken: string): Date | null {
+  const payload = decodeJwtPayload(accessToken);
+  return typeof payload?.exp === "number" ? new Date(payload.exp * 1000) : null;
+}
+
+/** id_token -> {chatgptAccountId, planType, isFedramp}. server.rs:827-832; token_data.rs:71-99 */
+export function parseIdToken(idToken: string): {
+  chatgptAccountId: string | null;
+  planType: string | null;
+  isFedramp: boolean;
+  email: string | null;
+} {
+  const payload = decodeJwtPayload(idToken);
+  const auth = (payload?.[CODEX_ID_TOKEN_AUTH_CLAIM] ?? {}) as Record<string, unknown>;
+  return {
+    chatgptAccountId: typeof auth.chatgpt_account_id === "string" ? auth.chatgpt_account_id : null,
+    planType: typeof auth.chatgpt_plan_type === "string" ? auth.chatgpt_plan_type : null,
+    isFedramp: auth.chatgpt_account_is_fedramp === true,
+    // The user's own email (standard OIDC `email` claim on the id_token); a
+    // non-secret display field for the accounts UI. Null when absent.
+    email: typeof payload?.email === "string" ? payload.email : null,
+  };
+}

package/src/request-context.ts

@@ -0,0 +1,50 @@
+// Per-request Codex context, carried via AsyncLocalStorage.
+//
+// The runtime caches one OpenAI client per provider id (process-wide), so the
+// per-workspace token must NOT be baked into the client. Instead the worker sets
+// this context around the model run, and codexSubscriptionFetch reads it at call
+// time — one cached client, correct per-workspace token, no cross-tenant leak.
+
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export type CodexTokenSnapshot = {
+  accessToken: string;
+  chatgptAccountId: string | null;
+  isFedramp: boolean;
+};
+
+/**
+ * Multi-account P4 (Part A): a full usage snapshot scraped FOR FREE from the
+ * `x-codex-primary-*` / `x-codex-secondary-*` response headers the codex backend
+ * stamps on every `/codex/responses` turn (success AND 429 hard-cap). Integer-
+ * identical to GET /wham/usage but with zero extra round-trip. parseCodexUsageHeaders
+ * returns this only when BOTH windows parse, so a write is always a full 5-column
+ * snapshot (no partial-window clobber). Shape mirrors db's CodexAccountUsageSnapshot
+ * (non-null here: a partial read is filtered to null upstream, never half-written).
+ */
+export type CodexUsageHeaderSnapshot = {
+  primaryUsedPercent: number;
+  primaryResetAt: Date;
+  secondaryUsedPercent: number;
+  secondaryResetAt: Date;
+  checkedAt: Date;
+};
+
+export type CodexRequestContext = {
+  clientVersion: string;
+  /** Worker-supplied: proactive refresh + single-flight + db persist. */
+  getToken: () => Promise<CodexTokenSnapshot>;
+  /** Forced refresh used for the 401 retry. */
+  refresh: () => Promise<CodexTokenSnapshot>;
+  /** Model-slug resolver (longest-prefix against the live catalog). */
+  resolveModel: (slug: string) => string;
+  /**
+   * Multi-account P4 (Part A): fire-and-forget usage-header sink. Called by
+   * codexSubscriptionFetch on EVERY response (sync, non-throwing, never awaited)
+   * with the parsed full-window snapshot. The worker records the latest into the
+   * P2 usage cache once per turn in its `finally` — packages/codex stays db-free.
+   */
+  onUsageHeaders?: (snapshot: CodexUsageHeaderSnapshot) => void;
+};
+
+export const codexRequestStorage = new AsyncLocalStorage<CodexRequestContext>();

package/src/usage-normalize.ts

@@ -0,0 +1,263 @@
+// Normalizer for GET /wham/usage (P2). The live body exposes `used_percent` +
+// reset timing per window and NO raw used/limit/remaining integer counts (the only
+// raw counts live under `credits.approx_*_messages`). So the brief's
+// used/limit/remaining/percent/resetAt shape is SYNTHESIZED off `used_percent`,
+// with `percent` authoritative and used/limit/remaining carried on a normalized
+// 0–100 scale (limit = 100). `remaining = 100 - percent` is the P3 rotation key
+// (rotationStrategy:"most_remaining" ranks by max(min(fiveHour, weekly).remaining)).
+//
+// Windows are identified by `limit_window_seconds` (18000 ⇒ 5h, 604800 ⇒ weekly),
+// NEVER by position. A 200 may carry `limit_reached:true`; a 404 carries a
+// limit-reached body. The parser is zod over rate_limit.{primary,secondary}_window.
+
+import * as z from "zod/v4";
+
+/** The 5-hour (primary) window's `limit_window_seconds`. */
+export const CODEX_FIVE_HOUR_WINDOW_SECONDS = 18000;
+/** The weekly (secondary) window's `limit_window_seconds`. */
+export const CODEX_WEEKLY_WINDOW_SECONDS = 604800;
+
+/** One normalized usage window (applied to BOTH primary_window and secondary_window). */
+export type CodexUsageWindow = {
+  used: number; // = percent (0–100 scale, limit = 100)
+  limit: number; // = 100 (normalized; the provider gives no raw cap)
+  remaining: number; // = 100 - percent  ← P3 rotation key
+  percent: number; // = used_percent (authoritative)
+  resetAt: string | null; // ISO 8601, from reset_at*1000 (absolute), or derived from reset_after_seconds
+  resetAfterSeconds: number | null; // from reset_after_seconds (skew-free countdown)
+  limitWindowSeconds: number; // 18000 | 604800 — identify the window, never positional
+};
+
+/** One additional (per-feature) limit (forward-compat; P2 renders nothing from it). */
+export type CodexAdditionalLimit = {
+  limitName: string;
+  meteredFeature: string;
+  fiveHour: CodexUsageWindow | null;
+  weekly: CodexUsageWindow | null;
+};
+
+export type CodexUsageStatus = "ok" | "limit_reached" | "error" | "no-data";
+
+/** The normalized usage payload — the P2/P3 contract. */
+export type CodexUsagePayload = {
+  status: CodexUsageStatus;
+  planType: string | null; // "pro" | "plus" | ... (rate row label)
+  fiveHour: CodexUsageWindow | null; // ← rate_limit.primary_window  (limitWindowSeconds === 18000)
+  weekly: CodexUsageWindow | null; // ← rate_limit.secondary_window (604800)
+  limitReached: boolean; // rate_limit.limit_reached || !rate_limit.allowed
+  fetchedAt: string; // ISO; server stamp
+  /** Present only on a refresh/auth failure path; carries the precise reason. */
+  reason?: "needs_relogin" | undefined;
+  // forward-compat, populated but unused in P2:
+  additionalLimits?: CodexAdditionalLimit[] | undefined;
+  credits?: { hasCredits: boolean; unlimited: boolean; overageLimitReached: boolean; balance: string } | undefined;
+};
+
+/**
+ * Build a normalized window from the PERSISTED cache columns (used_percent +
+ * absolute reset timestamp). The same 0–100 synthesis as the live path, with the
+ * skew-free countdown derived from `resetAt − now` at read time. Returns null when
+ * there is no cached percent yet. `limitWindowSeconds` is the constant that
+ * identifies the window (18000 ⇒ 5h, 604800 ⇒ weekly).
+ */
+export function buildCodexUsageWindowFromCache(
+  usedPercent: number | null | undefined,
+  resetAt: Date | string | null | undefined,
+  limitWindowSeconds: number,
+): CodexUsageWindow | null {
+  if (typeof usedPercent !== "number") {
+    return null;
+  }
+  const percent = clampPercent(usedPercent);
+  const resetDate = resetAt ? new Date(resetAt) : null;
+  const resetIso = resetDate && !Number.isNaN(resetDate.getTime()) ? resetDate.toISOString() : null;
+  const resetAfterSeconds = resetDate && !Number.isNaN(resetDate.getTime())
+    ? Math.max(0, Math.round((resetDate.getTime() - Date.now()) / 1000))
+    : null;
+  return {
+    used: percent,
+    limit: 100,
+    remaining: 100 - percent,
+    percent,
+    resetAt: resetIso,
+    resetAfterSeconds,
+    limitWindowSeconds,
+  };
+}
+
+const windowSchema = z
+  .object({
+    used_percent: z.number().optional(),
+    reset_after_seconds: z.number().optional(),
+    reset_at: z.number().optional(),
+    limit_window_seconds: z.number().optional(),
+  })
+  .nullish();
+
+const rateLimitSchema = z
+  .object({
+    allowed: z.boolean().optional(),
+    limit_reached: z.boolean().optional(),
+    primary_window: windowSchema,
+    secondary_window: windowSchema,
+  })
+  .nullish();
+
+const additionalLimitSchema = z.object({
+  limit_name: z.string().optional(),
+  metered_feature: z.string().optional(),
+  primary_window: windowSchema,
+  secondary_window: windowSchema,
+});
+
+const creditsSchema = z
+  .object({
+    has_credits: z.boolean().optional(),
+    unlimited: z.boolean().optional(),
+    overage_limit_reached: z.boolean().optional(),
+    balance: z.union([z.string(), z.number()]).optional(),
+  })
+  .nullish();
+
+const usageBodySchema = z.object({
+  plan_type: z.string().nullish(),
+  rate_limit: rateLimitSchema,
+  additional_limits: z.array(additionalLimitSchema).nullish(),
+  credits: creditsSchema,
+});
+
+type RawWindow = z.infer<typeof windowSchema>;
+
+function clampPercent(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(100, Math.max(0, Math.round(value)));
+}
+
+/** Build a normalized window from a raw provider window, or null when it carries no percent. */
+function normalizeWindow(w: RawWindow): CodexUsageWindow | null {
+  if (!w || typeof w.used_percent !== "number") {
+    return null;
+  }
+  const percent = clampPercent(w.used_percent);
+  const resetAfterSeconds = typeof w.reset_after_seconds === "number" ? Math.max(0, Math.round(w.reset_after_seconds)) : null;
+  let resetAt: string | null = null;
+  if (typeof w.reset_at === "number") {
+    resetAt = new Date(w.reset_at * 1000).toISOString(); // epoch SECONDS → ms
+  } else if (resetAfterSeconds != null) {
+    resetAt = new Date(Date.now() + resetAfterSeconds * 1000).toISOString();
+  }
+  return {
+    used: percent,
+    limit: 100,
+    remaining: 100 - percent,
+    percent,
+    resetAt,
+    resetAfterSeconds,
+    limitWindowSeconds: typeof w.limit_window_seconds === "number" ? w.limit_window_seconds : 0,
+  };
+}
+
+/**
+ * Map the two named windows to fiveHour/weekly by `limit_window_seconds`
+ * (18000 vs 604800), NEVER by position; fall back to position (primary ⇒ 5h,
+ * secondary ⇒ weekly) only for a window whose limit_window_seconds is absent.
+ */
+function pickWindows(primary: RawWindow, secondary: RawWindow): { fiveHour: CodexUsageWindow | null; weekly: CodexUsageWindow | null } {
+  let fiveHour: CodexUsageWindow | null = null;
+  let weekly: CodexUsageWindow | null = null;
+  // Track each unplaced window with the slot it came from, so the positional
+  // fallback can place it (re-normalizing produces a fresh object that would
+  // never match by reference — the bug this replaces).
+  const unplaced: Array<{ slot: "primary" | "secondary"; window: CodexUsageWindow }> = [];
+  for (const [slot, raw] of [["primary", primary], ["secondary", secondary]] as const) {
+    const nw = normalizeWindow(raw);
+    if (!nw) continue;
+    if (nw.limitWindowSeconds === CODEX_WEEKLY_WINDOW_SECONDS) {
+      weekly = nw;
+    } else if (nw.limitWindowSeconds === CODEX_FIVE_HOUR_WINDOW_SECONDS) {
+      fiveHour = nw;
+    } else {
+      unplaced.push({ slot, window: nw });
+    }
+  }
+  // Positional fallback for windows whose limit_window_seconds was absent/unknown
+  // (primary ⇒ 5h, secondary ⇒ weekly).
+  for (const { slot, window } of unplaced) {
+    if (slot === "primary" && !fiveHour) fiveHour = window;
+    else if (slot === "secondary" && !weekly) weekly = window;
+  }
+  return { fiveHour, weekly };
+}
+
+/**
+ * Normalize a /wham/usage fetch result into the P2/P3 contract.
+ *
+ * @param httpStatus the HTTP status from fetchCodexUsage (404 ⇒ a limit body)
+ * @param rawPayload the parsed JSON body (or null when the body was unreadable)
+ */
+export function normalizeCodexUsage(httpStatus: number, rawPayload: unknown): CodexUsagePayload {
+  const fetchedAt = new Date().toISOString();
+  const parsed = usageBodySchema.safeParse(rawPayload);
+  const body = parsed.success ? parsed.data : null;
+
+  const base: CodexUsagePayload = {
+    status: "no-data",
+    planType: body?.plan_type ?? null,
+    fiveHour: null,
+    weekly: null,
+    limitReached: false,
+    fetchedAt,
+  };
+
+  // A non-404 HTTP error, or a body we could not parse at all, is an error state.
+  if ((httpStatus >= 400 && httpStatus !== 404) || body == null) {
+    return { ...base, status: "error" };
+  }
+
+  const rate = body.rate_limit ?? null;
+  const { fiveHour, weekly } = pickWindows(rate?.primary_window ?? null, rate?.secondary_window ?? null);
+  const limitReached =
+    !!(rate?.limit_reached || rate?.allowed === false) || (fiveHour?.percent ?? 0) >= 100 || (weekly?.percent ?? 0) >= 100;
+
+  const additionalLimits: CodexAdditionalLimit[] | undefined = body.additional_limits
+    ? body.additional_limits.map((al) => {
+        const windows = pickWindows(al.primary_window ?? null, al.secondary_window ?? null);
+        return {
+          limitName: al.limit_name ?? "",
+          meteredFeature: al.metered_feature ?? "",
+          fiveHour: windows.fiveHour,
+          weekly: windows.weekly,
+        };
+      })
+    : undefined;
+
+  const credits = body.credits
+    ? {
+        hasCredits: body.credits.has_credits ?? false,
+        unlimited: body.credits.unlimited ?? false,
+        overageLimitReached: body.credits.overage_limit_reached ?? false,
+        balance: body.credits.balance != null ? String(body.credits.balance) : "0",
+      }
+    : undefined;
+
+  // Status derivation: 404 ⇒ limit_reached; a 200 may still carry limit_reached;
+  // succeeded-but-no-windows ⇒ no-data; otherwise ok.
+  let status: CodexUsageStatus;
+  if (httpStatus === 404 || limitReached) {
+    status = "limit_reached";
+  } else if (!fiveHour && !weekly) {
+    status = "no-data";
+  } else {
+    status = "ok";
+  }
+
+  return {
+    ...base,
+    status,
+    fiveHour,
+    weekly,
+    limitReached,
+    ...(additionalLimits ? { additionalLimits } : {}),
+    ...(credits ? { credits } : {}),
+  };
+}