@opengeni/xai-subscription 0.1.0

package/dist/index.js

@@ -0,0 +1,1245 @@
+import {
+  XAI_CLIENT_MODE,
+  XAI_CLIENT_VERSION,
+  XAI_DEVICE_AUTHORIZATION_URL,
+  XAI_DEVICE_CODE_GRANT_TYPE,
+  XAI_IMAGE_MODEL,
+  XAI_IMAGE_REQUEST_TIMEOUT_MS,
+  XAI_OAUTH_CLIENT_ID,
+  XAI_OAUTH_ISSUER,
+  XAI_OAUTH_OPERATION_TIMEOUT_MS,
+  XAI_OAUTH_SCOPES,
+  XAI_PUBLIC_API_BASE_URL,
+  XAI_REFRESH_FALLBACK_MS,
+  XAI_REFRESH_WINDOW_MS,
+  XAI_RESPONSE_SDK_OUTER_TIMEOUT_MS,
+  XAI_SUBSCRIPTION_AUTO_COMPACTION_PERCENT,
+  XAI_SUBSCRIPTION_EFFECTIVE_CONTEXT_PERCENT,
+  XAI_SUBSCRIPTION_MODEL_AUTO_COMPACT_TOKEN_LIMIT,
+  XAI_SUBSCRIPTION_MODEL_CONTEXT_WINDOW_TOKENS,
+  XAI_SUBSCRIPTION_MODEL_EFFECTIVE_CONTEXT_WINDOW_TOKENS,
+  XAI_SUBSCRIPTION_MODEL_ID_PREFIX,
+  XAI_SUBSCRIPTION_MODEL_SLUGS,
+  XAI_SUBSCRIPTION_PROVIDER_ID,
+  XAI_SUBSCRIPTION_PROXY_BASE_URL,
+  XAI_TOKEN_AUTH_HEADER_VALUE,
+  XAI_TOKEN_URL,
+  XAI_USERINFO_URL,
+  XAI_VIDEO_DOWNLOAD_TIMEOUT_MS,
+  XAI_VIDEO_GENERATION_TIMEOUT_MS,
+  XAI_VIDEO_MODEL,
+  XAI_VIDEO_POLL_INTERVAL_MS,
+  XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS,
+  XAI_VIDEO_START_TIMEOUT_MS
+} from "./chunk-JEFGIUGN.js";
+
+// src/errors.ts
+var XaiSubscriptionError = class extends Error {
+  constructor(kind, message, status) {
+    super(message);
+    this.kind = kind;
+    this.status = status;
+    this.name = "XaiSubscriptionError";
+  }
+};
+var XaiSubscriptionReloginRequired = class extends XaiSubscriptionError {
+  constructor(message = "The SuperGrok connection is no longer valid. Reconnect the account.") {
+    super("relogin_required", message);
+    this.name = "XaiSubscriptionReloginRequired";
+  }
+};
+var XaiSubscriptionTransientError = class extends XaiSubscriptionError {
+  constructor(message, status) {
+    super("transient", message, status);
+    this.name = "XaiSubscriptionTransientError";
+  }
+};
+
+// src/bounded-operation.ts
+async function runBoundedXaiOperation(operation, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("xAI operation timeout must be positive");
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  let timeout;
+  const work = operation(controller.signal).then(
+    (value) => ({ ok: true, value }),
+    () => ({
+      ok: false,
+      reason: timedOut || controller.signal.aborted ? "timeout" : "network_error"
+    })
+  );
+  const deadline = new Promise((resolve) => {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+      resolve({ ok: false, reason: "timeout" });
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([work, deadline]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+// src/oauth.ts
+import {
+  OAUTH_MAX_RESPONSE_BYTES,
+  readResponseJsonBounded,
+  validateHttpUrl
+} from "@opengeni/network";
+function oauthHeaders() {
+  return new Headers({
+    accept: "application/json",
+    "content-type": "application/x-www-form-urlencoded",
+    "user-agent": `opengeni/${XAI_CLIENT_VERSION}`,
+    "x-grok-client-version": XAI_CLIENT_VERSION,
+    "x-grok-client-surface": "headless"
+  });
+}
+function positiveSeconds(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.ceil(number) : fallback;
+}
+function requireNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new XaiSubscriptionError("invalid_response", `xAI OAuth response is missing ${field}`);
+  }
+  return value;
+}
+function nullableString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function validateUserCode(userCode) {
+  if (![...userCode].every((char) => /[A-Za-z0-9-]/.test(char))) {
+    throw new XaiSubscriptionError("invalid_response", "xAI returned an invalid user code");
+  }
+}
+function validateVerificationUri(uri) {
+  try {
+    return validateHttpUrl(uri, {
+      allowLoopbackHttp: true,
+      label: "xAI device verification"
+    });
+  } catch {
+    throw new XaiSubscriptionError("invalid_response", "xAI returned an invalid verification URL");
+  }
+}
+async function boundedFetchJson(label, input, init, options) {
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? XAI_OAUTH_OPERATION_TIMEOUT_MS;
+  const fetched = await runBoundedXaiOperation(async (signal) => {
+    const response = await fetchImpl(input, { ...init, signal });
+    const body = await readResponseJsonBounded(
+      response,
+      OAUTH_MAX_RESPONSE_BYTES,
+      label,
+      { signal }
+    );
+    return { response, body };
+  }, timeoutMs);
+  if (!fetched.ok) {
+    throw new XaiSubscriptionTransientError(`xAI ${label} ${fetched.reason}`);
+  }
+  return fetched.value;
+}
+async function requestXaiDeviceCode(options = {}) {
+  const { response, body } = await boundedFetchJson(
+    "device code request",
+    options.deviceAuthorizationUrl ?? XAI_DEVICE_AUTHORIZATION_URL,
+    {
+      method: "POST",
+      headers: oauthHeaders(),
+      body: new URLSearchParams({
+        client_id: options.clientId ?? XAI_OAUTH_CLIENT_ID,
+        scope: XAI_OAUTH_SCOPES.join(" "),
+        referrer: "opengeni"
+      }).toString()
+    },
+    options
+  );
+  if (response.status === 404) {
+    throw new XaiSubscriptionError(
+      "not_enabled",
+      "SuperGrok device-code login is not enabled by xAI",
+      404
+    );
+  }
+  if (!response.ok) {
+    throw new XaiSubscriptionTransientError(
+      `xAI device code request failed (${response.status})`,
+      response.status
+    );
+  }
+  const deviceCode = requireNonEmptyString(body.device_code, "device_code");
+  const userCode = requireNonEmptyString(body.user_code, "user_code");
+  const verificationUri = validateVerificationUri(
+    requireNonEmptyString(body.verification_uri, "verification_uri")
+  );
+  const verificationUriComplete = nullableString(body.verification_uri_complete);
+  validateUserCode(userCode);
+  return {
+    deviceCode,
+    userCode,
+    verificationUri,
+    verificationUriComplete: verificationUriComplete ? validateVerificationUri(verificationUriComplete) : null,
+    expiresInSeconds: positiveSeconds(body.expires_in, 5 * 60),
+    intervalSeconds: Math.max(1, positiveSeconds(body.interval, 5))
+  };
+}
+async function pollXaiDeviceCode(input, options = {}) {
+  const { response, body } = await boundedFetchJson(
+    "device token exchange",
+    options.tokenUrl ?? XAI_TOKEN_URL,
+    {
+      method: "POST",
+      headers: oauthHeaders(),
+      body: new URLSearchParams({
+        grant_type: XAI_DEVICE_CODE_GRANT_TYPE,
+        client_id: options.clientId ?? XAI_OAUTH_CLIENT_ID,
+        device_code: input.deviceCode
+      }).toString()
+    },
+    options
+  );
+  if (response.ok) {
+    return { status: "authorized", tokens: parseTokenResponse(body, true) };
+  }
+  const code = nullableString(body.error);
+  if (code === "authorization_pending") {
+    return { status: "pending", intervalSeconds: Math.max(1, input.intervalSeconds) };
+  }
+  if (code === "slow_down") {
+    return { status: "slow_down", intervalSeconds: Math.max(1, input.intervalSeconds) + 5 };
+  }
+  if (code === "access_denied" || code === "authorization_denied") {
+    return { status: "denied" };
+  }
+  if (code === "expired_token") {
+    return { status: "expired" };
+  }
+  throw new XaiSubscriptionTransientError(
+    `xAI device token exchange failed (${response.status})`,
+    response.status
+  );
+}
+async function refreshXaiToken(refreshToken, options = {}) {
+  const { response, body } = await boundedFetchJson(
+    "token refresh",
+    options.tokenUrl ?? XAI_TOKEN_URL,
+    {
+      method: "POST",
+      headers: oauthHeaders(),
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: options.clientId ?? XAI_OAUTH_CLIENT_ID
+      }).toString()
+    },
+    options
+  );
+  if (!response.ok) {
+    const code = nullableString(body.error);
+    if (response.status === 401 || code === "invalid_grant" || code === "invalid_token" || code === "access_denied") {
+      throw new XaiSubscriptionReloginRequired();
+    }
+    throw new XaiSubscriptionTransientError(
+      `xAI token refresh failed (${response.status})`,
+      response.status
+    );
+  }
+  const parsed = parseTokenResponse(body, false);
+  return {
+    ...parsed,
+    refreshToken: parsed.refreshToken || refreshToken
+  };
+}
+function parseTokenResponse(body, requireRefresh) {
+  const accessToken = requireNonEmptyString(body.access_token, "access_token");
+  const refreshToken = nullableString(body.refresh_token);
+  if (requireRefresh && !refreshToken) {
+    throw new XaiSubscriptionError(
+      "invalid_response",
+      "xAI OAuth response is missing refresh_token"
+    );
+  }
+  return {
+    accessToken,
+    refreshToken: refreshToken ?? "",
+    idToken: nullableString(body.id_token),
+    tokenType: nullableString(body.token_type),
+    scope: nullableString(body.scope),
+    expiresInSeconds: positiveSeconds(body.expires_in, 60 * 60)
+  };
+}
+async function fetchXaiVerifiedIdentity(accessToken, options = {}) {
+  const headers = new Headers({
+    accept: "application/json",
+    authorization: `Bearer ${accessToken}`,
+    "user-agent": `opengeni/${XAI_CLIENT_VERSION}`,
+    "x-grok-client-version": XAI_CLIENT_VERSION
+  });
+  const { response, body } = await boundedFetchJson(
+    "userinfo request",
+    options.userinfoUrl ?? XAI_USERINFO_URL,
+    { method: "GET", headers },
+    options
+  );
+  if (response.status === 401 || response.status === 403) {
+    throw new XaiSubscriptionReloginRequired();
+  }
+  if (!response.ok) {
+    throw new XaiSubscriptionTransientError(
+      `xAI userinfo request failed (${response.status})`,
+      response.status
+    );
+  }
+  return {
+    subject: requireNonEmptyString(body.sub, "userinfo sub"),
+    email: nullableString(body.email),
+    emailVerified: typeof body.email_verified === "boolean" ? body.email_verified : null,
+    name: nullableString(body.name)
+  };
+}
+function decodeXaiJwtPayload(jwt) {
+  const payload = jwt.split(".")[1];
+  if (!payload) return null;
+  try {
+    return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function xaiAccessTokenExpiry(accessToken) {
+  const payload = decodeXaiJwtPayload(accessToken);
+  return typeof payload?.exp === "number" ? new Date(payload.exp * 1e3) : null;
+}
+
+// src/request-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var xaiSubscriptionRequestStorage = new AsyncLocalStorage();
+
+// src/normalize.ts
+var XAI_INTERNAL_MODEL_HANDOFF_PREFIX = "supergrok/";
+function normalizeXaiSubscriptionRequestBody(value, resolveModel, hostedSearch) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("SuperGrok subscription request body must be a JSON object");
+  }
+  const body = { ...value };
+  if (typeof body.model !== "string") {
+    throw new Error("SuperGrok subscription request is missing model");
+  }
+  const candidate = body.model.startsWith(XAI_INTERNAL_MODEL_HANDOFF_PREFIX) ? body.model.slice(XAI_INTERNAL_MODEL_HANDOFF_PREFIX.length) : body.model;
+  body.model = resolveModel(candidate);
+  body.store = false;
+  const include = Array.isArray(body.include) ? body.include.filter((entry) => typeof entry === "string") : [];
+  if (!include.includes("reasoning.encrypted_content")) {
+    include.push("reasoning.encrypted_content");
+  }
+  body.include = include;
+  const tools = Array.isArray(body.tools) ? body.tools.map(normalizeXaiSubscriptionTool) : [];
+  appendHostedTool(tools, "web_search", hostedSearch?.webSearch);
+  appendHostedTool(tools, "x_search", hostedSearch?.xSearch);
+  if (tools.length > 0) body.tools = tools;
+  return body;
+}
+function normalizeXaiSubscriptionTool(tool) {
+  if (!tool || typeof tool !== "object" || Array.isArray(tool)) return tool;
+  const record2 = tool;
+  if (record2.type !== "web_search") return tool;
+  const { search_context_size: _unsupported, ...supported } = record2;
+  return supported;
+}
+function appendHostedTool(tools, type, options) {
+  if (!options) return;
+  if (tools.some(
+    (tool) => tool && typeof tool === "object" && !Array.isArray(tool) && tool.type === type
+  )) {
+    return;
+  }
+  tools.push(normalizeXaiSubscriptionTool(options === true ? { type } : { type, ...options }));
+}
+function normalizeXaiResponseEventJson(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { value, finalContextTokens: null };
+  }
+  const event = value;
+  const response = event.response && typeof event.response === "object" && !Array.isArray(event.response) ? { ...event.response } : null;
+  if (!response) return { value, finalContextTokens: null };
+  let changed = false;
+  if (Array.isArray(response.tools)) {
+    const filtered = response.tools.filter((tool) => isOpenAiSdkResponseTool(tool));
+    if (filtered.length !== response.tools.length) {
+      response.tools = filtered;
+      changed = true;
+    }
+  }
+  let finalContextTokens = null;
+  if (event.type === "response.completed" || event.type === "response.incomplete") {
+    const usage = response.usage && typeof response.usage === "object" && !Array.isArray(response.usage) ? { ...response.usage } : null;
+    const context = usage?.context_details && typeof usage.context_details === "object" && !Array.isArray(usage.context_details) ? usage.context_details : null;
+    const inputTokens = finiteNonNegativeInteger(context?.input_tokens);
+    const outputTokens = finiteNonNegativeInteger(context?.output_tokens);
+    if (usage && inputTokens !== null && outputTokens !== null) {
+      finalContextTokens = inputTokens + outputTokens;
+      usage.total_tokens = finalContextTokens;
+      response.usage = usage;
+      changed = true;
+    }
+  }
+  return {
+    value: changed ? { ...event, response } : value,
+    finalContextTokens
+  };
+}
+function finiteNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function isOpenAiSdkResponseTool(tool) {
+  if (!tool || typeof tool !== "object" || Array.isArray(tool)) return false;
+  const type = tool.type;
+  return typeof type === "string" && [
+    "function",
+    "file_search",
+    "computer_use_preview",
+    "computer",
+    "web_search",
+    "web_search_preview",
+    "code_interpreter",
+    "image_generation",
+    "local_shell",
+    "shell",
+    "apply_patch",
+    "mcp",
+    "custom"
+  ].includes(type);
+}
+
+// src/fetch.ts
+import { randomUUID } from "crypto";
+var REPLAYABLE_REQUEST_BODY_FACTORY = Symbol.for("opengeni.replayable-request-body-factory");
+var XAI_SUBSCRIPTION_TRANSPORT_ERROR_HEADER = "x-opengeni-xai-subscription-transport-error";
+var XAI_SUBSCRIPTION_REQUEST_BODY_NORMALIZED_HEADER = "x-opengeni-xai-subscription-body-normalized";
+var XAI_SUBSCRIPTION_REQUEST_MODEL_HEADER = "x-opengeni-xai-subscription-model";
+var XAI_SUBSCRIPTION_REQUEST_ID_HEADER = "x-opengeni-xai-subscription-request-id";
+var MAX_ERROR_BODY_BYTES = 64 * 1024;
+function xaiSubscriptionFetch(base) {
+  return async (input, init) => {
+    const context = xaiSubscriptionRequestStorage.getStore();
+    if (!context) throw new Error("SuperGrok subscription request context is unavailable");
+    const originalUrl = input instanceof Request ? input.url : String(input);
+    const url = new URL(originalUrl);
+    if (!url.pathname.endsWith("/responses")) {
+      throw new Error("SuperGrok subscription models require the Responses API");
+    }
+    const originalHeaders = new Headers(input instanceof Request ? input.headers : void 0);
+    if (init?.headers) {
+      new Headers(init.headers).forEach((value, key) => originalHeaders.set(key, value));
+    }
+    const normalized = originalHeaders.get(XAI_SUBSCRIPTION_REQUEST_BODY_NORMALIZED_HEADER) === "1";
+    const requestId = originalHeaders.get(XAI_SUBSCRIPTION_REQUEST_ID_HEADER) ?? randomUUID();
+    const handedOffModel = originalHeaders.get(XAI_SUBSCRIPTION_REQUEST_MODEL_HEADER);
+    originalHeaders.delete(XAI_SUBSCRIPTION_REQUEST_BODY_NORMALIZED_HEADER);
+    originalHeaders.delete(XAI_SUBSCRIPTION_REQUEST_ID_HEADER);
+    originalHeaders.delete(XAI_SUBSCRIPTION_REQUEST_MODEL_HEADER);
+    const replayableBodyFactory = init?.[REPLAYABLE_REQUEST_BODY_FACTORY];
+    const body = await requestBodyText(input, init, replayableBodyFactory);
+    const parsed = body ? JSON.parse(body) : {};
+    const normalizedBody = normalized ? parsed : normalizeXaiSubscriptionRequestBody(parsed, context.resolveModel, context.hostedSearch);
+    const model = handedOffModel ?? (typeof normalizedBody.model === "string" ? normalizedBody.model : "grok-4.6");
+    const send = async (refresh) => {
+      const token = refresh ? await context.refresh() : await context.getToken();
+      const headers = new Headers(originalHeaders);
+      headers.set("authorization", `Bearer ${token.accessToken}`);
+      headers.set("content-type", "application/json");
+      headers.set("accept", "text/event-stream");
+      headers.set("user-agent", `opengeni/${context.clientVersion || XAI_CLIENT_VERSION}`);
+      headers.set("x-grok-client-version", context.clientVersion || XAI_CLIENT_VERSION);
+      headers.set("x-grok-client-identifier", "opengeni");
+      headers.set("x-grok-client-mode", XAI_CLIENT_MODE);
+      headers.set("x-authenticateresponse", "authenticate-response");
+      headers.set("x-xai-token-auth", XAI_TOKEN_AUTH_HEADER_VALUE);
+      headers.set("x-userid", token.userId);
+      headers.set("x-grok-user-id", token.userId);
+      headers.set("x-grok-conv-id", context.sessionId);
+      headers.set("x-grok-session-id", context.sessionId);
+      headers.set("x-grok-req-id", requestId);
+      headers.set("x-grok-agent-id", context.turnId);
+      headers.set("x-grok-model-override", model);
+      return await base(url, {
+        ...init,
+        method: init?.method ?? (input instanceof Request ? input.method : "POST"),
+        headers,
+        body: JSON.stringify(normalizedBody)
+      });
+    };
+    let response = await send(false);
+    if (response.status === 401) {
+      await response.body?.cancel().catch(() => void 0);
+      response = await send(true);
+    }
+    return await normalizeResponse(response, context.onFinalContextUsage);
+  };
+}
+async function requestBodyText(input, init, replayableBodyFactory) {
+  if (typeof init?.body === "string") return init.body;
+  if (input instanceof Request) return await input.clone().text();
+  if (replayableBodyFactory) return await new Response(replayableBodyFactory()).text();
+  if (init?.body === void 0 || init.body === null) return "";
+  throw new Error("SuperGrok subscription request body must be replayable JSON text");
+}
+async function normalizeResponse(response, onFinalContextUsage) {
+  if (!response.ok) {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const bounded = bytes.byteLength > MAX_ERROR_BODY_BYTES ? bytes.slice(0, MAX_ERROR_BODY_BYTES) : bytes;
+    const headers = new Headers(response.headers);
+    headers.set(XAI_SUBSCRIPTION_TRANSPORT_ERROR_HEADER, "1");
+    return new Response(bounded, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  if (!response.body) return response;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/event-stream")) {
+    const value = await response.json();
+    const normalized = normalizeXaiResponseEventJson({
+      type: "response.completed",
+      response: value
+    });
+    emitContextUsage(normalized.value, normalized.finalContextTokens, onFinalContextUsage);
+    const responseValue = normalized.value && typeof normalized.value === "object" && !Array.isArray(normalized.value) ? normalized.value.response : value;
+    return Response.json(responseValue, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let pending = "";
+  const body = new ReadableStream({
+    async pull(controller) {
+      const chunk = await reader.read();
+      pending += decoder.decode(chunk.value, { stream: !chunk.done });
+      const parts = pending.split("\n\n");
+      pending = parts.pop() ?? "";
+      for (const part of parts)
+        controller.enqueue(encoder.encode(`${normalizeSseEvent(part, onFinalContextUsage)}
+
+`));
+      if (chunk.done) {
+        if (pending)
+          controller.enqueue(encoder.encode(normalizeSseEvent(pending, onFinalContextUsage)));
+        controller.close();
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function normalizeSseEvent(block, onFinalContextUsage) {
+  const lines = block.split("\n");
+  return lines.map((line) => {
+    if (!line.startsWith("data:")) return line;
+    const data = line.slice(5).trimStart();
+    if (!data || data === "[DONE]") return line;
+    try {
+      const normalized = normalizeXaiResponseEventJson(JSON.parse(data));
+      emitContextUsage(normalized.value, normalized.finalContextTokens, onFinalContextUsage);
+      return `data: ${JSON.stringify(normalized.value)}`;
+    } catch {
+      return line;
+    }
+  }).join("\n");
+}
+function emitContextUsage(value, finalContextTokens, sink) {
+  if (finalContextTokens === null || !sink) return;
+  const response = value && typeof value === "object" && !Array.isArray(value) ? value.response : null;
+  const usage = response && typeof response === "object" && !Array.isArray(response) ? response.usage : null;
+  const context = usage && typeof usage === "object" && !Array.isArray(usage) ? usage.context_details : null;
+  if (!context || typeof context !== "object" || Array.isArray(context)) return;
+  const inputTokens = Number(context.input_tokens);
+  const outputTokens = Number(context.output_tokens);
+  if (!Number.isSafeInteger(inputTokens) || !Number.isSafeInteger(outputTokens)) return;
+  try {
+    sink({ inputTokens, outputTokens, totalTokens: finalContextTokens });
+  } catch {
+  }
+}
+function isXaiSubscriptionTransportError(error) {
+  let current = error;
+  for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
+    const value = current;
+    const headers = value.headers;
+    if (headers && typeof headers === "object" && typeof headers.get === "function" && headers.get(XAI_SUBSCRIPTION_TRANSPORT_ERROR_HEADER) === "1") {
+      return true;
+    }
+    current = value.cause;
+  }
+  return false;
+}
+
+// src/proxy.ts
+import { OAUTH_MAX_RESPONSE_BYTES as OAUTH_MAX_RESPONSE_BYTES2, pinnedFetch, readResponseJsonBounded as readResponseJsonBounded2 } from "@opengeni/network";
+var defaultProxyFetch = async (input, init) => await pinnedFetch(
+  input,
+  init,
+  { environment: "production", integrationsAllowPrivateNetworkTargets: false },
+  { label: "xAI subscription proxy", requireHttpsOutsideLocalTest: true }
+);
+async function fetchXaiProxyJson(input) {
+  const fetchImpl = input.fetch ?? defaultProxyFetch;
+  const timeoutMs = input.timeoutMs ?? 15e3;
+  const maxBytes = input.maxBytes ?? OAUTH_MAX_RESPONSE_BYTES2;
+  const url = `${(input.baseUrl ?? XAI_SUBSCRIPTION_PROXY_BASE_URL).replace(/\/+$/, "")}/${input.path.replace(/^\/+/, "")}`;
+  const request = async (token, signal) => {
+    const headers = xaiSubscriptionProxyHeaders(token, input.context.clientVersion);
+    return await fetchImpl(url, { method: "GET", redirect: "error", headers, signal });
+  };
+  const fetched = await runBoundedXaiOperation(async (signal) => {
+    let response = await request(await input.context.getToken(), signal);
+    if (response.status === 401) {
+      await response.body?.cancel().catch(() => void 0);
+      response = await request(await input.context.refresh(), signal);
+    }
+    if (response.status === 401 || response.status === 403) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new XaiSubscriptionReloginRequired();
+    }
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => void 0);
+      throw new XaiSubscriptionTransientError(
+        `xAI ${input.label} failed (${response.status})`,
+        response.status
+      );
+    }
+    return await readResponseJsonBounded2(response, maxBytes, `xAI ${input.label}`, { signal });
+  }, timeoutMs);
+  if (!fetched.ok) {
+    throw new XaiSubscriptionTransientError(`xAI ${input.label} ${fetched.reason}`);
+  }
+  return fetched.value;
+}
+function xaiSubscriptionProxyHeaders(token, clientVersion = XAI_CLIENT_VERSION) {
+  return new Headers({
+    accept: "application/json",
+    authorization: `Bearer ${token.accessToken}`,
+    "user-agent": `opengeni/${clientVersion}`,
+    "x-grok-client-version": clientVersion,
+    "x-grok-client-identifier": "opengeni",
+    "x-grok-client-mode": XAI_CLIENT_MODE,
+    "x-authenticateresponse": "authenticate-response",
+    "x-xai-token-auth": XAI_TOKEN_AUTH_HEADER_VALUE,
+    "x-userid": token.userId,
+    "x-grok-user-id": token.userId
+  });
+}
+
+// src/quota.ts
+async function fetchXaiSubscriptionQuota(input) {
+  const body = await fetchXaiProxyJson({
+    path: "billing?format=credits",
+    context: input.context,
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.timeoutMs ? { timeoutMs: input.timeoutMs } : {},
+    ...input.baseUrl ? { baseUrl: input.baseUrl } : {},
+    label: "billing request"
+  });
+  const config = record(body.config);
+  const currentPeriod = record(config?.currentPeriod ?? config?.current_period);
+  const monthlyLimit = cents(config?.monthlyLimit ?? config?.monthly_limit);
+  const used = cents(config?.used);
+  const directPercent = finitePercent(config?.creditUsagePercent ?? config?.credit_usage_percent);
+  const derivedPercent = monthlyLimit !== null && monthlyLimit > 0 && used !== null ? Math.max(0, Math.min(100, used / monthlyLimit * 100)) : null;
+  const period = currentPeriod ? {
+    type: stringOrNull(currentPeriod.type),
+    start: dateOrNull(currentPeriod.start),
+    end: dateOrNull(currentPeriod.end)
+  } : legacyPeriod(config);
+  return {
+    usedPercent: directPercent ?? derivedPercent,
+    period,
+    prepaidBalanceCents: cents(config?.prepaidBalance ?? config?.prepaid_balance),
+    onDemandCapCents: cents(config?.onDemandCap ?? config?.on_demand_cap),
+    onDemandUsedCents: cents(config?.onDemandUsed ?? config?.on_demand_used),
+    onDemandEnabled: booleanOrNull(body.onDemandEnabled ?? body.on_demand_enabled),
+    unifiedBilling: booleanOrNull(config?.isUnifiedBillingUser ?? config?.is_unified_billing_user),
+    subscriptionTier: stringOrNull(body.subscriptionTier ?? body.subscription_tier),
+    checkedAt: /* @__PURE__ */ new Date()
+  };
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function cents(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value)) return value;
+  const object = record(value);
+  const candidate = object?.val;
+  return typeof candidate === "number" && Number.isSafeInteger(candidate) ? candidate : null;
+}
+function finitePercent(value) {
+  const candidate = Number(value);
+  return Number.isFinite(candidate) ? Math.max(0, Math.min(100, candidate)) : null;
+}
+function stringOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function booleanOrNull(value) {
+  return typeof value === "boolean" ? value : null;
+}
+function dateOrNull(value) {
+  if (typeof value !== "string") return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function legacyPeriod(config) {
+  const start = dateOrNull(config?.billingPeriodStart ?? config?.billing_period_start);
+  const end = dateOrNull(config?.billingPeriodEnd ?? config?.billing_period_end);
+  return start || end ? { type: null, start, end } : null;
+}
+
+// src/models.ts
+async function fetchXaiSubscriptionModels(input) {
+  const body = await fetchXaiProxyJson({
+    path: "models",
+    context: input.context,
+    ...input.fetch ? { fetch: input.fetch } : {},
+    ...input.timeoutMs ? { timeoutMs: input.timeoutMs } : {},
+    ...input.baseUrl ? { baseUrl: input.baseUrl } : {},
+    maxBytes: 4 * 1024 * 1024,
+    label: "model metadata request"
+  });
+  const values = Array.isArray(body) ? body : body && typeof body === "object" && Array.isArray(body.data) ? body.data : [];
+  return values.flatMap((value) => {
+    const parsed = parseXaiSubscriptionModelMetadata(value);
+    return parsed ? [parsed] : [];
+  });
+}
+function parseXaiSubscriptionModelMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const object = value;
+  const meta = object._meta && typeof object._meta === "object" && !Array.isArray(object._meta) ? object._meta : {};
+  const slug = firstString(object.model, object.modelId, object.id, meta.model, meta.modelId);
+  const contextWindowTokens = firstPositiveInteger(
+    object.contextWindow,
+    object.context_window,
+    meta.contextWindow,
+    meta.totalContextTokens
+  );
+  if (!slug || contextWindowTokens === null) return null;
+  const effectivePercent = firstPositiveInteger(
+    object.effectiveContextWindowPercent,
+    object.effective_context_window_percent
+  ) ?? XAI_SUBSCRIPTION_EFFECTIVE_CONTEXT_PERCENT;
+  const autoCompactPercent = firstPositiveInteger(
+    object.autoCompactThresholdPercent,
+    object.auto_compact_threshold_percent
+  ) ?? XAI_SUBSCRIPTION_AUTO_COMPACTION_PERCENT;
+  const backend = firstString(object.apiBackend, object.api_backend);
+  return {
+    slug,
+    name: firstString(object.name) ?? slug,
+    contextWindowTokens,
+    effectiveContextWindowTokens: Math.floor(contextWindowTokens * effectivePercent / 100),
+    autoCompactTokenLimit: Math.floor(contextWindowTokens * autoCompactPercent / 100),
+    maxCompletionTokens: firstPositiveInteger(
+      object.maxCompletionTokens,
+      object.max_completion_tokens
+    ),
+    apiBackend: backend === "chat_completions" || backend === "messages" ? backend : "responses"
+  };
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+function firstPositiveInteger(...values) {
+  for (const value of values) {
+    const number = Number(value);
+    if (Number.isSafeInteger(number) && number > 0) return number;
+  }
+  return null;
+}
+
+// src/images.ts
+import { pinnedFetch as pinnedFetch2, readJsonBase64Field, readResponseTextBounded } from "@opengeni/network";
+var XAI_IMAGE_RESPONSE_MAX_BYTES = 90 * 1024 * 1024;
+var XAI_IMAGE_MAX_BYTES = 64 * 1024 * 1024;
+var XAI_IMAGE_ERROR_MAX_BYTES = 64 * 1024;
+var defaultImageFetch = async (input, init) => await pinnedFetch2(
+  input,
+  init,
+  { environment: "production", integrationsAllowPrivateNetworkTargets: false },
+  { label: "xAI image generation", requireHttpsOutsideLocalTest: true }
+);
+async function generateXaiSubscriptionImage(input) {
+  const timeoutMs = input.requestTimeoutMs ?? XAI_IMAGE_REQUEST_TIMEOUT_MS;
+  const deadline = new AbortController();
+  const timer = setTimeout(
+    () => deadline.abort(new XaiSubscriptionError("timeout", "xAI image generation timed out")),
+    timeoutMs
+  );
+  const signal = input.abortSignal ? AbortSignal.any([input.abortSignal, deadline.signal]) : deadline.signal;
+  const fetchImpl = input.fetch ?? defaultImageFetch;
+  const references = input.references ?? [];
+  if (references.length > 3) {
+    throw new XaiSubscriptionError(
+      "provider_rejected",
+      "xAI image editing supports at most three references"
+    );
+  }
+  const url = `${(input.baseUrl ?? XAI_PUBLIC_API_BASE_URL).replace(/\/+$/, "")}/images/${references.length > 0 ? "edits" : "generations"}`;
+  const request = async (token) => await fetchImpl(url, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${token.accessToken}`,
+      "content-type": "application/json",
+      "user-agent": `opengeni/${XAI_CLIENT_VERSION}`,
+      "x-grok-client-version": XAI_CLIENT_VERSION,
+      "x-grok-client-identifier": "opengeni",
+      ...input.sessionId ? { "x-grok-session-id": input.sessionId } : {}
+    },
+    body: JSON.stringify(
+      references.length > 0 ? {
+        model: XAI_IMAGE_MODEL,
+        prompt: input.prompt,
+        n: 1,
+        resolution: "1k",
+        response_format: "b64_json",
+        ...references.length === 1 ? { image: referencePayload(references[0]) } : {
+          images: references.map(referencePayload),
+          aspect_ratio: input.aspectRatio ?? "auto"
+        }
+      } : {
+        model: XAI_IMAGE_MODEL,
+        prompt: input.prompt,
+        n: 1,
+        aspect_ratio: input.aspectRatio ?? "auto",
+        resolution: "1k",
+        response_format: "b64_json"
+      }
+    ),
+    signal
+  });
+  try {
+    let response = await request(await input.getToken());
+    if (response.status === 401) {
+      await response.body?.cancel().catch(() => void 0);
+      response = await request(await input.refresh());
+    }
+    if (!response.ok) {
+      const detail = await readResponseTextBounded(
+        response,
+        XAI_IMAGE_ERROR_MAX_BYTES,
+        "xAI image generation error",
+        { signal }
+      ).catch(() => "");
+      throw new XaiSubscriptionError(
+        "provider_rejected",
+        `xAI image generation failed (${response.status})${detail ? `: ${boundedMessage(detail)}` : ""}`,
+        response.status
+      );
+    }
+    const bytes = await readJsonBase64Field(response, {
+      fieldName: "b64_json",
+      shape: "string",
+      maxResponseBytes: XAI_IMAGE_RESPONSE_MAX_BYTES,
+      maxDecodedBytes: XAI_IMAGE_MAX_BYTES,
+      label: "xAI image generation",
+      signal
+    });
+    return { bytes, declaredMediaType: detectImageMediaType(bytes) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function referencePayload(reference) {
+  return {
+    url: `data:${reference.mediaType};base64,${Buffer.from(reference.bytes).toString("base64")}`
+  };
+}
+function detectImageMediaType(bytes) {
+  if (bytes.byteLength >= 8 && [137, 80, 78, 71, 13, 10, 26, 10].every((byte, index) => bytes[index] === byte)) {
+    return "image/png";
+  }
+  if (bytes.byteLength >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  if (bytes.byteLength >= 12 && String.fromCharCode(...bytes.subarray(0, 4)) === "RIFF" && String.fromCharCode(...bytes.subarray(8, 12)) === "WEBP") {
+    return "image/webp";
+  }
+  throw new XaiSubscriptionError("invalid_response", "xAI returned an unsupported image format");
+}
+function boundedMessage(body) {
+  try {
+    const value = JSON.parse(body);
+    const error = value.error && typeof value.error === "object" && !Array.isArray(value.error) ? value.error : null;
+    const message = error?.message ?? value.message;
+    if (typeof message === "string") return message.replace(/\s+/g, " ").trim().slice(0, 1e3);
+  } catch {
+  }
+  return body.replace(/\s+/g, " ").trim().slice(0, 1e3);
+}
+
+// src/video.ts
+import {
+  pinnedFetch as pinnedFetch3,
+  readResponseBodyBounded,
+  readResponseJsonBounded as readResponseJsonBounded3,
+  readResponseTextBounded as readResponseTextBounded2,
+  validateHttpUrl as validateHttpUrl2
+} from "@opengeni/network";
+var XAI_VIDEO_MAX_BYTES = 256 * 1024 * 1024;
+var XAI_VIDEO_ERROR_MAX_BYTES = 64 * 1024;
+var defaultVideoFetch = async (input, init) => await pinnedFetch3(
+  input,
+  init,
+  {
+    environment: "production",
+    integrationsAllowPrivateNetworkTargets: false
+  },
+  { label: "xAI video generation", requireHttpsOutsideLocalTest: true }
+);
+async function startXaiSubscriptionVideoWithBody(input) {
+  const fetchImpl = input.fetch ?? defaultVideoFetch;
+  const baseUrl = (input.baseUrl ?? XAI_PUBLIC_API_BASE_URL).replace(/\/+$/, "");
+  const request = async (token) => await fetchWithDeadline(
+    fetchImpl,
+    `${baseUrl}/videos/generations`,
+    {
+      method: "POST",
+      redirect: "error",
+      headers: publicVideoHeaders(token, input.sessionId, true),
+      body: JSON.stringify(input.body),
+      ...input.signal ? { signal: input.signal } : {}
+    },
+    XAI_VIDEO_START_TIMEOUT_MS,
+    input.signal ?? AbortSignal.timeout(XAI_VIDEO_START_TIMEOUT_MS)
+  );
+  let response = await request(await input.getToken());
+  if (response.status === 401) {
+    await response.body?.cancel().catch(() => void 0);
+    response = await request(await input.refresh());
+  }
+  if (!response.ok)
+    throw await providerError("start", response, input.signal ?? new AbortController().signal);
+  const body = await readResponseJsonBounded3(
+    response,
+    1024 * 1024,
+    "xAI video start",
+    input.signal ? { signal: input.signal } : {}
+  );
+  if (typeof body.request_id !== "string" || !body.request_id.trim()) {
+    throw new XaiSubscriptionError("invalid_response", "xAI video start response is malformed");
+  }
+  return { providerJobId: body.request_id };
+}
+async function getXaiSubscriptionVideoStatus(input) {
+  if (!input.providerJobId.trim() || input.providerJobId.length > 1024) {
+    throw new Error("xAI video job identity is invalid");
+  }
+  const fetchImpl = input.fetch ?? defaultVideoFetch;
+  const baseUrl = (input.baseUrl ?? XAI_PUBLIC_API_BASE_URL).replace(/\/+$/, "");
+  const request = async (token) => await fetchWithDeadline(
+    fetchImpl,
+    `${baseUrl}/videos/${encodeURIComponent(input.providerJobId)}`,
+    {
+      method: "GET",
+      redirect: "error",
+      headers: publicVideoHeaders(token, input.sessionId, false),
+      ...input.signal ? { signal: input.signal } : {}
+    },
+    XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS,
+    input.signal ?? AbortSignal.timeout(XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS)
+  );
+  let response = await request(await input.getToken());
+  if (response.status === 401) {
+    await response.body?.cancel().catch(() => void 0);
+    response = await request(await input.refresh());
+  }
+  if (!response.ok && response.status !== 202) {
+    throw await providerError("poll", response, input.signal ?? new AbortController().signal);
+  }
+  const body = await readResponseJsonBounded3(
+    response,
+    1024 * 1024,
+    "xAI video poll",
+    input.signal ? { signal: input.signal } : {}
+  );
+  if (body.status === "pending" || body.status === "queued" || body.status === "running") {
+    return { status: "pending" };
+  }
+  if (body.status === "failed" || body.status === "expired") {
+    return {
+      status: "error",
+      publicReason: `xAI video generation ${body.status}`
+    };
+  }
+  const video = body.video && typeof body.video === "object" && !Array.isArray(body.video) ? body.video : null;
+  if (body.status !== "done" || typeof video?.url !== "string") {
+    throw new XaiSubscriptionError("invalid_response", "xAI video poll response is malformed");
+  }
+  return {
+    status: "completed",
+    outputUrl: validateMediaUrl(video.url),
+    mediaType: "video/mp4"
+  };
+}
+function publicVideoHeaders(token, sessionId, json) {
+  return new Headers({
+    accept: "application/json",
+    authorization: `Bearer ${token.accessToken}`,
+    "user-agent": `opengeni/${XAI_CLIENT_VERSION}`,
+    "x-grok-client-version": XAI_CLIENT_VERSION,
+    "x-grok-client-identifier": "opengeni",
+    "x-grok-client-mode": XAI_CLIENT_MODE,
+    ...sessionId ? { "x-grok-session-id": sessionId } : {},
+    ...json ? { "content-type": "application/json" } : {}
+  });
+}
+async function generateXaiSubscriptionVideo(input) {
+  const baseUrl = (input.baseUrl ?? XAI_PUBLIC_API_BASE_URL).replace(/\/+$/, "");
+  const fetchImpl = input.fetch ?? defaultVideoFetch;
+  const deadline = new AbortController();
+  const timeoutMs = input.generationTimeoutMs ?? XAI_VIDEO_GENERATION_TIMEOUT_MS;
+  const timer = setTimeout(
+    () => deadline.abort(new XaiSubscriptionError("timeout", "xAI video generation timed out")),
+    timeoutMs
+  );
+  const signal = input.abortSignal ? AbortSignal.any([input.abortSignal, deadline.signal]) : deadline.signal;
+  const references = (input.referenceImageUrls ?? []).map(validateMediaUrl);
+  const image = input.imageUrl ? validateMediaUrl(input.imageUrl) : void 0;
+  const request = async (token) => await fetchWithDeadline(
+    fetchImpl,
+    `${baseUrl}/videos/generations`,
+    {
+      method: "POST",
+      redirect: "error",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${token.accessToken}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: XAI_VIDEO_MODEL,
+        prompt: input.prompt,
+        ...image ? { image: { url: image } } : {},
+        ...references.length > 0 ? { reference_images: references.map((url) => ({ url })) } : {},
+        ...input.durationSeconds ? { duration: input.durationSeconds } : {},
+        aspect_ratio: input.aspectRatio ?? "16:9",
+        resolution: input.resolution ?? "480p"
+      }),
+      signal
+    },
+    XAI_VIDEO_START_TIMEOUT_MS,
+    signal
+  );
+  try {
+    let start = await request(await input.getToken());
+    if (start.status === 401) {
+      await start.body?.cancel().catch(() => void 0);
+      start = await request(await input.refresh());
+    }
+    if (!start.ok) throw await providerError("start", start, signal);
+    const started = await readResponseJsonBounded3(
+      start,
+      1024 * 1024,
+      "xAI video start",
+      { signal }
+    );
+    const requestId = typeof started.request_id === "string" && started.request_id.length > 0 ? started.request_id : null;
+    if (!requestId) {
+      throw new XaiSubscriptionError(
+        "invalid_response",
+        "xAI video generation did not return request_id"
+      );
+    }
+    const sleep = input.sleep ?? abortableSleep;
+    for (; ; ) {
+      await sleep(XAI_VIDEO_POLL_INTERVAL_MS, signal);
+      let poll = await pollVideo(fetchImpl, baseUrl, requestId, await input.getToken(), signal);
+      if (poll.status === 401) {
+        await poll.body?.cancel().catch(() => void 0);
+        poll = await pollVideo(fetchImpl, baseUrl, requestId, await input.refresh(), signal);
+      }
+      if (!poll.ok && poll.status !== 202) throw await providerError("poll", poll, signal);
+      const status = await readResponseJsonBounded3(
+        poll,
+        1024 * 1024,
+        "xAI video poll",
+        { signal }
+      );
+      if (status.status === "failed" || status.status === "expired") {
+        throw new XaiSubscriptionError(
+          "provider_rejected",
+          `xAI video generation ${status.status}`
+        );
+      }
+      if (status.status !== "done") continue;
+      const video = status.video && typeof status.video === "object" && !Array.isArray(status.video) ? status.video : null;
+      const downloadUrl = typeof video?.url === "string" ? validateMediaUrl(video.url) : null;
+      if (!downloadUrl) {
+        throw new XaiSubscriptionError(
+          "invalid_response",
+          "xAI video generation completed without a download URL"
+        );
+      }
+      const download = await fetchWithDeadline(
+        fetchImpl,
+        downloadUrl,
+        { method: "GET", redirect: "error", signal },
+        XAI_VIDEO_DOWNLOAD_TIMEOUT_MS,
+        signal
+      );
+      if (!download.ok) throw await providerError("download", download, signal);
+      const bytes = await readResponseBodyBounded(
+        download,
+        XAI_VIDEO_MAX_BYTES,
+        "xAI video download",
+        { signal }
+      );
+      return { bytes, declaredMediaType: "video/mp4", requestId };
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function pollVideo(fetchImpl, baseUrl, requestId, token, signal) {
+  return await fetchWithDeadline(
+    fetchImpl,
+    `${baseUrl}/videos/${encodeURIComponent(requestId)}`,
+    {
+      method: "GET",
+      redirect: "error",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${token.accessToken}`
+      },
+      signal
+    },
+    XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS,
+    signal
+  );
+}
+async function fetchWithDeadline(fetchImpl, url, init, timeoutMs, outerSignal) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return await fetchImpl(url, {
+    ...init,
+    signal: AbortSignal.any([outerSignal, timeout])
+  });
+}
+async function providerError(phase, response, signal) {
+  const detail = await readResponseTextBounded2(
+    response,
+    XAI_VIDEO_ERROR_MAX_BYTES,
+    `xAI video ${phase} error`,
+    { signal }
+  ).catch(() => "");
+  return new XaiSubscriptionError(
+    "provider_rejected",
+    `xAI video ${phase} failed (${response.status})${detail ? `: ${detail.replace(/\s+/g, " ").trim().slice(0, 1e3)}` : ""}`,
+    response.status
+  );
+}
+function validateMediaUrl(value) {
+  try {
+    return validateHttpUrl2(value, { label: "xAI media" });
+  } catch {
+    throw new XaiSubscriptionError("invalid_response", "xAI returned an invalid media URL");
+  }
+}
+async function abortableSleep(ms, signal) {
+  if (signal.aborted) throw signal.reason;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(done, ms);
+    const onAbort = () => done(signal.reason);
+    function done(error) {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      if (error === void 0) {
+        resolve();
+      } else {
+        reject(error);
+      }
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+export {
+  XAI_CLIENT_MODE,
+  XAI_CLIENT_VERSION,
+  XAI_DEVICE_AUTHORIZATION_URL,
+  XAI_DEVICE_CODE_GRANT_TYPE,
+  XAI_IMAGE_MODEL,
+  XAI_IMAGE_REQUEST_TIMEOUT_MS,
+  XAI_OAUTH_CLIENT_ID,
+  XAI_OAUTH_ISSUER,
+  XAI_OAUTH_OPERATION_TIMEOUT_MS,
+  XAI_OAUTH_SCOPES,
+  XAI_PUBLIC_API_BASE_URL,
+  XAI_REFRESH_FALLBACK_MS,
+  XAI_REFRESH_WINDOW_MS,
+  XAI_RESPONSE_SDK_OUTER_TIMEOUT_MS,
+  XAI_SUBSCRIPTION_AUTO_COMPACTION_PERCENT,
+  XAI_SUBSCRIPTION_EFFECTIVE_CONTEXT_PERCENT,
+  XAI_SUBSCRIPTION_MODEL_AUTO_COMPACT_TOKEN_LIMIT,
+  XAI_SUBSCRIPTION_MODEL_CONTEXT_WINDOW_TOKENS,
+  XAI_SUBSCRIPTION_MODEL_EFFECTIVE_CONTEXT_WINDOW_TOKENS,
+  XAI_SUBSCRIPTION_MODEL_ID_PREFIX,
+  XAI_SUBSCRIPTION_MODEL_SLUGS,
+  XAI_SUBSCRIPTION_PROVIDER_ID,
+  XAI_SUBSCRIPTION_PROXY_BASE_URL,
+  XAI_SUBSCRIPTION_REQUEST_BODY_NORMALIZED_HEADER,
+  XAI_SUBSCRIPTION_REQUEST_ID_HEADER,
+  XAI_SUBSCRIPTION_REQUEST_MODEL_HEADER,
+  XAI_SUBSCRIPTION_TRANSPORT_ERROR_HEADER,
+  XAI_TOKEN_AUTH_HEADER_VALUE,
+  XAI_TOKEN_URL,
+  XAI_USERINFO_URL,
+  XAI_VIDEO_DOWNLOAD_TIMEOUT_MS,
+  XAI_VIDEO_GENERATION_TIMEOUT_MS,
+  XAI_VIDEO_MODEL,
+  XAI_VIDEO_POLL_INTERVAL_MS,
+  XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS,
+  XAI_VIDEO_START_TIMEOUT_MS,
+  XaiSubscriptionError,
+  XaiSubscriptionReloginRequired,
+  XaiSubscriptionTransientError,
+  decodeXaiJwtPayload,
+  fetchXaiProxyJson,
+  fetchXaiSubscriptionModels,
+  fetchXaiSubscriptionQuota,
+  fetchXaiVerifiedIdentity,
+  generateXaiSubscriptionImage,
+  generateXaiSubscriptionVideo,
+  getXaiSubscriptionVideoStatus,
+  isXaiSubscriptionTransportError,
+  normalizeXaiResponseEventJson,
+  normalizeXaiSubscriptionRequestBody,
+  parseXaiSubscriptionModelMetadata,
+  pollXaiDeviceCode,
+  refreshXaiToken,
+  requestXaiDeviceCode,
+  runBoundedXaiOperation,
+  startXaiSubscriptionVideoWithBody,
+  xaiAccessTokenExpiry,
+  xaiSubscriptionFetch,
+  xaiSubscriptionProxyHeaders,
+  xaiSubscriptionRequestStorage
+};
+//# sourceMappingURL=index.js.map