@opengeni/codex 0.2.0

package/dist/index.js

@@ -0,0 +1,879 @@
+import {
+  CODEX_APPS_MCP_SERVER_ID,
+  CODEX_APPS_MCP_SERVER_NAME,
+  CODEX_APPS_MCP_URL,
+  CODEX_APPS_REQUIRED_SCOPES,
+  CODEX_APPS_STARTUP_TIMEOUT_MS,
+  CODEX_AUTH_BASE,
+  CODEX_CLIENT_ID,
+  CODEX_CLIENT_VERSION,
+  CODEX_DEVICE_REDIRECT_URI,
+  CODEX_DEVICE_VERIFICATION_URL,
+  CODEX_FALLBACK_MODEL_SLUGS,
+  CODEX_ID_TOKEN_AUTH_CLAIM,
+  CODEX_ISSUER,
+  CODEX_MODEL_ID_PREFIX,
+  CODEX_ORIGINATOR,
+  CODEX_PROVIDER_BASE_URL,
+  CODEX_PROVIDER_ID,
+  CODEX_REFRESH_FALLBACK_MS,
+  CODEX_REFRESH_WINDOW_MS,
+  CODEX_RESPONSES_BASE,
+  CODEX_TOKEN_URL,
+  CODEX_WHAM_BASE
+} from "./chunk-2ESTGQ57.js";
+
+// src/billing.ts
+function isCodexBilledModel(model) {
+  return typeof model === "string" && model.startsWith(CODEX_MODEL_ID_PREFIX);
+}
+
+// src/device-code.ts
+var CodexDeviceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexDeviceError";
+  }
+};
+async function startDeviceCode(fetchImpl = fetch) {
+  const res = await fetchImpl(`${CODEX_AUTH_BASE}/deviceauth/usercode`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CODEX_CLIENT_ID })
+  });
+  if (res.status === 404) {
+    throw new CodexDeviceError("device code login is not enabled for this Codex server");
+  }
+  if (!res.ok) {
+    throw new CodexDeviceError(`device code request failed with status ${res.status}`);
+  }
+  const body = await res.json();
+  return {
+    deviceAuthId: body.device_auth_id,
+    userCode: body.user_code ?? body.usercode ?? "",
+    verificationUri: CODEX_DEVICE_VERIFICATION_URL,
+    intervalSeconds: normalizeInterval(body.interval)
+  };
+}
+function normalizeInterval(raw) {
+  const n = typeof raw === "string" ? Number.parseInt(raw.trim(), 10) : raw;
+  return typeof n === "number" && Number.isFinite(n) && n >= 1 ? n : 5;
+}
+async function pollDeviceCode(input, fetchImpl = fetch) {
+  const res = await fetchImpl(`${CODEX_AUTH_BASE}/deviceauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ device_auth_id: input.deviceAuthId, user_code: input.userCode })
+  });
+  if (res.ok) {
+    const body = await res.json();
+    return { status: "authorized", authorizationCode: body.authorization_code, codeVerifier: body.code_verifier };
+  }
+  if (res.status === 403 || res.status === 404) {
+    return { status: "pending" };
+  }
+  throw new CodexDeviceError(`device auth failed with status ${res.status}`);
+}
+async function exchangeDeviceCode(input, fetchImpl = fetch) {
+  const form = new URLSearchParams({
+    grant_type: "authorization_code",
+    code: input.authorizationCode,
+    redirect_uri: CODEX_DEVICE_REDIRECT_URI,
+    client_id: CODEX_CLIENT_ID,
+    code_verifier: input.codeVerifier
+  });
+  const res = await fetchImpl(CODEX_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: form.toString()
+  });
+  if (!res.ok) {
+    throw new CodexDeviceError(`device code exchange failed with status ${res.status}`);
+  }
+  const body = await res.json();
+  return { idToken: body.id_token, accessToken: body.access_token, refreshToken: body.refresh_token };
+}
+
+// src/refresh.ts
+var CodexReloginRequired = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexReloginRequired";
+  }
+};
+var CodexRefreshTransient = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexRefreshTransient";
+  }
+};
+async function refreshCodexToken(refreshToken, fetchImpl = fetch) {
+  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] : void 0;
+    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);
+  return { idToken: body.id_token, accessToken: body.access_token, refreshToken: body.refresh_token };
+}
+var PERMANENT_REFRESH_FAILURES = {
+  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."
+};
+function extractRefreshErrorCode(text) {
+  try {
+    const o = JSON.parse(text);
+    const err = o.error;
+    if (typeof err === "string") {
+      return err;
+    }
+    if (err && typeof err === "object") {
+      const e = err;
+      if (typeof e.code === "string") return e.code;
+      if (typeof e.type === "string") return e.type;
+    }
+    if (typeof o.code === "string") return o.code;
+    if (typeof o.type === "string") return o.type;
+  } catch {
+  }
+  return void 0;
+}
+function decodeJwtPayload(jwt) {
+  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);
+  } catch {
+    return null;
+  }
+}
+function accessTokenExpiry(accessToken) {
+  const payload = decodeJwtPayload(accessToken);
+  return typeof payload?.exp === "number" ? new Date(payload.exp * 1e3) : null;
+}
+function parseIdToken(idToken) {
+  const payload = decodeJwtPayload(idToken);
+  const auth = payload?.[CODEX_ID_TOKEN_AUTH_CLAIM] ?? {};
+  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
+  };
+}
+
+// src/normalize.ts
+var MINIMAL = "minimal";
+var CODEX_ALLOWED_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "instructions",
+  "input",
+  "tools",
+  "tool_choice",
+  "parallel_tool_calls",
+  "reasoning",
+  "store",
+  "stream",
+  "include",
+  "prompt_cache_key",
+  "text"
+]);
+function normalizeCodexRequestBody(body, resolveModel) {
+  body.store = false;
+  body.stream = true;
+  const include = Array.isArray(body.include) ? body.include.filter((v) => typeof v === "string") : [];
+  if (!include.includes("reasoning.encrypted_content")) {
+    include.push("reasoning.encrypted_content");
+  }
+  body.include = include;
+  const reasoning = body.reasoning;
+  if (reasoning && reasoning.effort === MINIMAL) {
+    reasoning.effort = "low";
+  }
+  if (typeof body.model === "string") {
+    body.model = resolveModel(body.model);
+  }
+  if (Array.isArray(body.input)) {
+    for (const item of body.input) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      const record = item;
+      if ("id" in record) {
+        delete record.id;
+      }
+      if (record.type === "tool_search_call" && typeof record.arguments === "string") {
+        try {
+          const parsed = JSON.parse(record.arguments);
+          record.arguments = parsed && typeof parsed === "object" ? parsed : {};
+        } catch {
+          record.arguments = {};
+        }
+      }
+    }
+  }
+  if (Array.isArray(body.tools)) {
+    body.tools = body.tools.filter(
+      (t) => !(t && typeof t === "object" && t.type === "mcp")
+    );
+  }
+  for (const key of Object.keys(body)) {
+    if (!CODEX_ALLOWED_TOP_LEVEL_KEYS.has(key)) {
+      delete body[key];
+    }
+  }
+  return body;
+}
+function buildModelResolver(liveSlugs, fallbackSlug) {
+  return (requested) => {
+    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;
+  };
+}
+
+// src/usage-normalize.ts
+import * as z from "zod/v4";
+var CODEX_FIVE_HOUR_WINDOW_SECONDS = 18e3;
+var CODEX_WEEKLY_WINDOW_SECONDS = 604800;
+function buildCodexUsageWindowFromCache(usedPercent, resetAt, limitWindowSeconds) {
+  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()) / 1e3)) : null;
+  return {
+    used: percent,
+    limit: 100,
+    remaining: 100 - percent,
+    percent,
+    resetAt: resetIso,
+    resetAfterSeconds,
+    limitWindowSeconds
+  };
+}
+var 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();
+var rateLimitSchema = z.object({
+  allowed: z.boolean().optional(),
+  limit_reached: z.boolean().optional(),
+  primary_window: windowSchema,
+  secondary_window: windowSchema
+}).nullish();
+var additionalLimitSchema = z.object({
+  limit_name: z.string().optional(),
+  metered_feature: z.string().optional(),
+  primary_window: windowSchema,
+  secondary_window: windowSchema
+});
+var 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();
+var usageBodySchema = z.object({
+  plan_type: z.string().nullish(),
+  rate_limit: rateLimitSchema,
+  additional_limits: z.array(additionalLimitSchema).nullish(),
+  credits: creditsSchema
+});
+function clampPercent(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(100, Math.max(0, Math.round(value)));
+}
+function normalizeWindow(w) {
+  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 = null;
+  if (typeof w.reset_at === "number") {
+    resetAt = new Date(w.reset_at * 1e3).toISOString();
+  } else if (resetAfterSeconds != null) {
+    resetAt = new Date(Date.now() + resetAfterSeconds * 1e3).toISOString();
+  }
+  return {
+    used: percent,
+    limit: 100,
+    remaining: 100 - percent,
+    percent,
+    resetAt,
+    resetAfterSeconds,
+    limitWindowSeconds: typeof w.limit_window_seconds === "number" ? w.limit_window_seconds : 0
+  };
+}
+function pickWindows(primary, secondary) {
+  let fiveHour = null;
+  let weekly = null;
+  const unplaced = [];
+  for (const [slot, raw] of [["primary", primary], ["secondary", secondary]]) {
+    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 });
+    }
+  }
+  for (const { slot, window } of unplaced) {
+    if (slot === "primary" && !fiveHour) fiveHour = window;
+    else if (slot === "secondary" && !weekly) weekly = window;
+  }
+  return { fiveHour, weekly };
+}
+function normalizeCodexUsage(httpStatus, rawPayload) {
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const parsed = usageBodySchema.safeParse(rawPayload);
+  const body = parsed.success ? parsed.data : null;
+  const base = {
+    status: "no-data",
+    planType: body?.plan_type ?? null,
+    fiveHour: null,
+    weekly: null,
+    limitReached: false,
+    fetchedAt
+  };
+  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 = 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
+    };
+  }) : void 0;
+  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"
+  } : void 0;
+  let status;
+  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 } : {}
+  };
+}
+
+// src/api-client.ts
+function subscriptionHeaders(a) {
+  return {
+    Authorization: `Bearer ${a.accessToken}`,
+    ...a.chatgptAccountId ? { "ChatGPT-Account-ID": a.chatgptAccountId } : {},
+    originator: CODEX_ORIGINATOR,
+    "User-Agent": `${CODEX_ORIGINATOR}/${a.clientVersion}`,
+    version: a.clientVersion,
+    ...a.isFedramp ? { "X-OpenAI-Fedramp": "true" } : {}
+  };
+}
+async function fetchCodexModels(a, fetchImpl = fetch) {
+  const res = await fetchImpl(`${CODEX_RESPONSES_BASE}/models?client_version=${encodeURIComponent(a.clientVersion)}`, {
+    method: "GET",
+    headers: subscriptionHeaders(a)
+  });
+  if (!res.ok) {
+    return { ok: false, status: res.status, slugs: [] };
+  }
+  const body = await res.json();
+  const slugs = (body.models ?? []).map((m) => m.slug).filter((s) => typeof s === "string");
+  return { ok: true, status: res.status, slugs };
+}
+async function fetchCodexUsage(a, fetchImpl = fetch) {
+  const res = await fetchImpl(`${CODEX_WHAM_BASE}/wham/usage`, {
+    method: "GET",
+    headers: subscriptionHeaders(a)
+  });
+  const payload = res.ok || res.status === 404 ? await res.json().catch(() => null) : null;
+  return { status: res.status, payload };
+}
+
+// src/request-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var codexRequestStorage = new AsyncLocalStorage();
+
+// src/fetch.ts
+function parseIntHeader(value) {
+  if (value === null) {
+    return null;
+  }
+  const n = Number.parseInt(value.trim(), 10);
+  return Number.isFinite(n) ? n : null;
+}
+function resolveResetAt(headers, atKey, afterKey, nowMs) {
+  const at = parseIntHeader(headers.get(atKey));
+  if (at !== null) {
+    return new Date(at * 1e3);
+  }
+  const after = parseIntHeader(headers.get(afterKey));
+  if (after !== null) {
+    return new Date(nowMs + after * 1e3);
+  }
+  return new Date(nowMs);
+}
+function parseCodexUsageHeaders(headers) {
+  const primaryUsedPercent = parseIntHeader(headers.get("x-codex-primary-used-percent"));
+  const secondaryUsedPercent = parseIntHeader(headers.get("x-codex-secondary-used-percent"));
+  if (primaryUsedPercent === null || secondaryUsedPercent === null) {
+    return null;
+  }
+  const nowMs = Date.now();
+  return {
+    primaryUsedPercent,
+    primaryResetAt: resolveResetAt(headers, "x-codex-primary-reset-at", "x-codex-primary-reset-after-seconds", nowMs),
+    secondaryUsedPercent,
+    secondaryResetAt: resolveResetAt(headers, "x-codex-secondary-reset-at", "x-codex-secondary-reset-after-seconds", nowMs),
+    checkedAt: new Date(nowMs)
+  };
+}
+function codexSubscriptionFetch(base = globalThis.fetch) {
+  return async (input, init) => {
+    const ctx = codexRequestStorage.getStore();
+    if (!ctx) {
+      return base(input, init);
+    }
+    const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const rewritten = rawUrl.replace(/(?<!\/codex)\/responses(\b|$)/, "/codex/responses$1");
+    const attempt = async (auth) => {
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${auth.accessToken}`);
+      if (auth.chatgptAccountId) {
+        headers.set("ChatGPT-Account-ID", auth.chatgptAccountId);
+      }
+      headers.set("originator", CODEX_ORIGINATOR);
+      headers.set("User-Agent", `${CODEX_ORIGINATOR}/${ctx.clientVersion}`);
+      headers.set("version", ctx.clientVersion);
+      headers.set("accept", "text/event-stream");
+      headers.set("content-type", "application/json");
+      if (auth.isFedramp) {
+        headers.set("X-OpenAI-Fedramp", "true");
+      }
+      headers.delete("OpenAI-Beta");
+      headers.delete("x-api-key");
+      let callerWantsStream = true;
+      const nextInit = { ...init, headers };
+      if (typeof init?.body === "string") {
+        try {
+          const parsed = JSON.parse(init.body);
+          callerWantsStream = parsed.stream === true;
+          nextInit.body = JSON.stringify(normalizeCodexRequestBody(parsed, ctx.resolveModel));
+        } catch {
+        }
+      }
+      if (process.env.CODEX_DEBUG) {
+        const keys = typeof nextInit.body === "string" ? Object.keys(JSON.parse(nextInit.body)) : [];
+        console.error(`[codex-debug] POST ${rewritten} stream=${callerWantsStream} bodyKeys=[${keys.join(",")}]`);
+      }
+      const res2 = await base(rewritten, nextInit);
+      const usage = parseCodexUsageHeaders(res2.headers);
+      if (usage) {
+        ctx.onUsageHeaders?.(usage);
+      }
+      if (process.env.CODEX_DEBUG && !res2.ok) {
+        console.error(`[codex-debug] <- ${res2.status} ${await res2.clone().text()}`);
+      }
+      if (!res2.ok) {
+        return await bufferCodexErrorResponse(res2);
+      }
+      return callerWantsStream ? repairCodexStream(res2) : await sseToJsonResponse(res2);
+    };
+    let res = await attempt(await ctx.getToken());
+    if (res.status === 401) {
+      res = await attempt(await ctx.refresh());
+    }
+    return res;
+  };
+}
+var CODEX_USAGE_LIMIT_ERROR_TYPE = "usage_limit_reached";
+function classifyCodexUsageLimitError(error) {
+  let cur = error;
+  for (let depth = 0; depth < 6 && cur && typeof cur === "object"; depth++) {
+    const e = cur;
+    const body = e.error && typeof e.error === "object" ? e.error : void 0;
+    const type = (typeof e.type === "string" ? e.type : void 0) ?? (typeof body?.type === "string" ? body.type : void 0);
+    const message = typeof e.message === "string" ? e.message : "";
+    const status = Number(e.status);
+    if (type === CODEX_USAGE_LIMIT_ERROR_TYPE || message.includes(CODEX_USAGE_LIMIT_ERROR_TYPE) || status === 429 && /usage limit/i.test(message)) {
+      const resets = (typeof body?.resets_in_seconds === "number" ? body.resets_in_seconds : void 0) ?? (typeof e.resets_in_seconds === "number" ? e.resets_in_seconds : void 0) ?? null;
+      return { resetsInSeconds: resets };
+    }
+    cur = e.cause;
+  }
+  return null;
+}
+async function bufferCodexErrorResponse(res) {
+  const bodyText = await res.text().catch(() => "");
+  const headers = new Headers(res.headers);
+  headers.set("content-type", "application/json");
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  let errorType;
+  try {
+    const parsed = JSON.parse(bodyText);
+    errorType = typeof parsed.error?.type === "string" ? parsed.error.type : void 0;
+  } catch {
+  }
+  if (errorType === CODEX_USAGE_LIMIT_ERROR_TYPE) {
+    headers.set("x-should-retry", "false");
+  }
+  return new Response(bodyText, { status: res.status, statusText: res.statusText, headers });
+}
+async function sseToJsonResponse(res) {
+  const text = await res.text();
+  let final = null;
+  const items = [];
+  for (const block of text.split("\n\n")) {
+    const data = block.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+    if (!data || data === "[DONE]") {
+      continue;
+    }
+    try {
+      const ev = JSON.parse(data);
+      if (ev.type === "response.output_item.done" && ev.item !== void 0) {
+        items.push(ev.item);
+      } else if (ev.type === "response.completed" || ev.type === "response.done" || ev.type === "response.incomplete") {
+        final = ev.response ?? null;
+      }
+    } catch {
+    }
+  }
+  if (final && items.length > 0) {
+    final = { ...final, output: items };
+  }
+  if (process.env.CODEX_DEBUG) {
+    console.error(`[codex-debug] sse->json items=${items.length} outputLen=${Array.isArray(final?.output) ? final.output.length : "?"}`);
+  }
+  const headers = new Headers(res.headers);
+  headers.set("content-type", "application/json");
+  headers.delete("content-length");
+  return new Response(JSON.stringify(final ?? {}), { status: 200, headers });
+}
+function repairCodexStream(res) {
+  if (!res.body) {
+    return res;
+  }
+  const items = [];
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  const transform = new TransformStream({
+    transform(chunk, controller) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let idx = buffer.indexOf("\n\n");
+      while (idx !== -1) {
+        const block = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        controller.enqueue(encoder.encode(`${patchSseBlock(block, items)}
+
+`));
+        idx = buffer.indexOf("\n\n");
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.enqueue(encoder.encode(patchSseBlock(buffer, items)));
+      }
+    }
+  });
+  const headers = new Headers(res.headers);
+  headers.delete("content-length");
+  return new Response(res.body.pipeThrough(transform), { status: res.status, headers });
+}
+function patchSseBlock(block, items) {
+  const lines = block.split("\n");
+  const dataStr = lines.filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
+  if (!dataStr || dataStr === "[DONE]") {
+    return block;
+  }
+  let ev;
+  try {
+    ev = JSON.parse(dataStr);
+  } catch {
+    return block;
+  }
+  if (ev.type === "response.output_item.done" && ev.item !== void 0) {
+    items.push(ev.item);
+    return block;
+  }
+  if ((ev.type === "response.completed" || ev.type === "response.done" || ev.type === "response.incomplete") && ev.response) {
+    const out = ev.response.output;
+    if ((!Array.isArray(out) || out.length === 0) && items.length > 0) {
+      ev.response = { ...ev.response, output: items };
+      const nonData = lines.filter((l) => !l.startsWith("data:"));
+      return [...nonData, `data: ${JSON.stringify(ev)}`].join("\n");
+    }
+  }
+  return block;
+}
+
+// src/mcp-sanitize.ts
+var VALID_TOOL_NAME = /^[a-zA-Z0-9_-]+$/;
+var MAX_TOOL_NAME_LEN = 64;
+var RUNTIME_TOOL_NAME_PREFIX_LEN = CODEX_APPS_MCP_SERVER_ID.length + "__".length;
+var EFFECTIVE_MAX_TOOL_NAME_LEN = MAX_TOOL_NAME_LEN - RUNTIME_TOOL_NAME_PREFIX_LEN;
+function shortHash(input) {
+  let h = 5381;
+  for (let i = 0; i < input.length; i++) {
+    h = (h << 5) + h + input.charCodeAt(i) >>> 0;
+  }
+  return h.toString(36);
+}
+function capLength(candidate, original) {
+  if (candidate.length <= EFFECTIVE_MAX_TOOL_NAME_LEN) {
+    return candidate;
+  }
+  const suffix = `_${shortHash(original)}`;
+  return candidate.slice(0, Math.max(0, EFFECTIVE_MAX_TOOL_NAME_LEN - suffix.length)) + suffix;
+}
+var ToolNameMapper = class {
+  sanitizedToOriginal = /* @__PURE__ */ new Map();
+  used = /* @__PURE__ */ new Set();
+  /** Return a legal, unique name (<= EFFECTIVE_MAX_TOOL_NAME_LEN, so `<prefix>__name` <= 64) for `original`, recording the reverse mapping. */
+  sanitize(original) {
+    let candidate = VALID_TOOL_NAME.test(original) ? original : original.replace(/[^a-zA-Z0-9_-]/g, "_") || "tool";
+    candidate = capLength(candidate, original);
+    if (this.used.has(candidate) && this.sanitizedToOriginal.get(candidate) !== original) {
+      const base = candidate;
+      let n = 2;
+      do {
+        const suffix = `_${n++}`;
+        candidate = (base.length + suffix.length > EFFECTIVE_MAX_TOOL_NAME_LEN ? base.slice(0, EFFECTIVE_MAX_TOOL_NAME_LEN - suffix.length) : base) + suffix;
+      } while (this.used.has(candidate));
+    }
+    this.used.add(candidate);
+    this.sanitizedToOriginal.set(candidate, original);
+    return candidate;
+  }
+  /** Reverse a sanitized name back to the MCP server's original, if known. */
+  toOriginal(sanitized) {
+    return this.sanitizedToOriginal.get(sanitized);
+  }
+};
+function sanitizeToolsInRpcMessage(message, mapper, namespaceSink) {
+  if (!message || typeof message !== "object") {
+    return;
+  }
+  const tools = message.result?.tools;
+  if (!Array.isArray(tools)) {
+    return;
+  }
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object") {
+      continue;
+    }
+    const record = tool;
+    if ("outputSchema" in record) {
+      delete record.outputSchema;
+    }
+    if (typeof record.name === "string") {
+      if (namespaceSink && record.name.includes(".")) {
+        const namespace = record.name.slice(0, record.name.indexOf("."));
+        if (namespace) {
+          namespaceSink.add(namespace);
+        }
+      }
+      record.name = mapper.sanitize(record.name);
+    }
+  }
+}
+function inlineStructuredContentInRpcMessage(message) {
+  if (!message || typeof message !== "object") {
+    return;
+  }
+  const result = message.result;
+  if (!result || typeof result !== "object") {
+    return;
+  }
+  const record = result;
+  if (!("structuredContent" in record)) {
+    return;
+  }
+  const structured = record.structuredContent;
+  if (structured === void 0 || structured === null) {
+    return;
+  }
+  const text = typeof structured === "string" ? structured : JSON.stringify(structured);
+  const content = Array.isArray(record.content) ? [...record.content] : [];
+  content.push({ type: "text", text });
+  record.content = content;
+}
+function sanitizeMcpJsonBody(text, mapper = new ToolNameMapper(), namespaceSink) {
+  try {
+    const parsed = JSON.parse(text);
+    sanitizeToolsInRpcMessage(parsed, mapper, namespaceSink);
+    inlineStructuredContentInRpcMessage(parsed);
+    return JSON.stringify(parsed);
+  } catch {
+    return text;
+  }
+}
+function sanitizeMcpSseBody(text, mapper = new ToolNameMapper(), namespaceSink) {
+  return text.split("\n").map((line) => {
+    if (!line.startsWith("data:")) {
+      return line;
+    }
+    const payload = line.slice("data:".length).trimStart();
+    try {
+      const parsed = JSON.parse(payload);
+      sanitizeToolsInRpcMessage(parsed, mapper, namespaceSink);
+      inlineStructuredContentInRpcMessage(parsed);
+      return `data: ${JSON.stringify(parsed)}`;
+    } catch {
+      return line;
+    }
+  }).join("\n");
+}
+function remapToolCallRequestBody(body, mapper) {
+  try {
+    const message = JSON.parse(body);
+    if (message.method !== "tools/call") {
+      return null;
+    }
+    const name = message.params?.name;
+    if (typeof name !== "string") {
+      return null;
+    }
+    const original = mapper.toOriginal(name);
+    if (original === void 0 || original === name) {
+      return null;
+    }
+    message.params.name = original;
+    return JSON.stringify(message);
+  } catch {
+    return null;
+  }
+}
+function codexAppsSanitizingFetch(base = globalThis.fetch, namespaceSink) {
+  const mapper = new ToolNameMapper();
+  return async (input, init) => {
+    let nextInit = init;
+    if (init && typeof init.body === "string" && (init.method ?? "GET").toUpperCase() === "POST") {
+      const remapped = remapToolCallRequestBody(init.body, mapper);
+      if (remapped !== null) {
+        nextInit = { ...init, body: remapped };
+      }
+    }
+    const res = await base(input, nextInit);
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    if (method !== "POST" || !res.ok || !res.body) {
+      return res;
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    const isJson = contentType.includes("application/json");
+    const isSse = contentType.includes("text/event-stream");
+    if (!isJson && !isSse) {
+      return res;
+    }
+    const originalBody = await res.text();
+    const sanitized = isJson ? sanitizeMcpJsonBody(originalBody, mapper, namespaceSink) : sanitizeMcpSseBody(originalBody, mapper, namespaceSink);
+    const headers = new Headers(res.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    return new Response(sanitized, { status: res.status, statusText: res.statusText, headers });
+  };
+}
+export {
+  CODEX_APPS_MCP_SERVER_ID,
+  CODEX_APPS_MCP_SERVER_NAME,
+  CODEX_APPS_MCP_URL,
+  CODEX_APPS_REQUIRED_SCOPES,
+  CODEX_APPS_STARTUP_TIMEOUT_MS,
+  CODEX_AUTH_BASE,
+  CODEX_CLIENT_ID,
+  CODEX_CLIENT_VERSION,
+  CODEX_DEVICE_REDIRECT_URI,
+  CODEX_DEVICE_VERIFICATION_URL,
+  CODEX_FALLBACK_MODEL_SLUGS,
+  CODEX_FIVE_HOUR_WINDOW_SECONDS,
+  CODEX_ID_TOKEN_AUTH_CLAIM,
+  CODEX_ISSUER,
+  CODEX_MODEL_ID_PREFIX,
+  CODEX_ORIGINATOR,
+  CODEX_PROVIDER_BASE_URL,
+  CODEX_PROVIDER_ID,
+  CODEX_REFRESH_FALLBACK_MS,
+  CODEX_REFRESH_WINDOW_MS,
+  CODEX_RESPONSES_BASE,
+  CODEX_TOKEN_URL,
+  CODEX_USAGE_LIMIT_ERROR_TYPE,
+  CODEX_WEEKLY_WINDOW_SECONDS,
+  CODEX_WHAM_BASE,
+  CodexDeviceError,
+  CodexRefreshTransient,
+  CodexReloginRequired,
+  ToolNameMapper,
+  accessTokenExpiry,
+  buildCodexUsageWindowFromCache,
+  buildModelResolver,
+  classifyCodexUsageLimitError,
+  codexAppsSanitizingFetch,
+  codexRequestStorage,
+  codexSubscriptionFetch,
+  decodeJwtPayload,
+  exchangeDeviceCode,
+  fetchCodexModels,
+  fetchCodexUsage,
+  isCodexBilledModel,
+  normalizeCodexRequestBody,
+  normalizeCodexUsage,
+  parseCodexUsageHeaders,
+  parseIdToken,
+  pollDeviceCode,
+  refreshCodexToken,
+  remapToolCallRequestBody,
+  sanitizeMcpJsonBody,
+  sanitizeMcpSseBody,
+  startDeviceCode
+};
+//# sourceMappingURL=index.js.map