@opengeni/xai-subscription 0.1.0 → 0.1.2-canary.0

package/dist/index.js

@@ -13,6 +13,7 @@ import {
   XAI_REFRESH_FALLBACK_MS,
   XAI_REFRESH_WINDOW_MS,
   XAI_RESPONSE_SDK_OUTER_TIMEOUT_MS,
+  XAI_RESPONSE_STREAM_IDLE_TIMEOUT_MS,
   XAI_SUBSCRIPTION_AUTO_COMPACTION_PERCENT,
   XAI_SUBSCRIPTION_EFFECTIVE_CONTEXT_PERCENT,
   XAI_SUBSCRIPTION_MODEL_AUTO_COMPACT_TOKEN_LIMIT,
@@ -31,7 +32,7 @@ import {
   XAI_VIDEO_POLL_INTERVAL_MS,
   XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS,
   XAI_VIDEO_START_TIMEOUT_MS
-} from "./chunk-JEFGIUGN.js";
+} from "./chunk-QSLO7YEK.js";
 
 // src/errors.ts
 var XaiSubscriptionError = class extends Error {
@@ -54,6 +55,113 @@ var XaiSubscriptionTransientError = class extends XaiSubscriptionError {
     this.name = "XaiSubscriptionTransientError";
   }
 };
+var XaiSubscriptionHostedToolContinuationError = class extends XaiSubscriptionError {
+  code = "xai_hosted_tool_continuation_stalled";
+  constructor() {
+    super(
+      "timeout",
+      "SuperGrok stopped responding after completing a hosted search. The partial response was preserved and was not replayed automatically."
+    );
+    this.name = "XaiSubscriptionHostedToolContinuationError";
+  }
+};
+var XaiSubscriptionStreamingTerminalError = class extends XaiSubscriptionError {
+  code;
+  eventType;
+  requestId;
+  diagnosticTruncated;
+  headers;
+  constructor(input) {
+    super("provider_rejected", input.message, input.status);
+    this.name = "XaiSubscriptionStreamingTerminalError";
+    this.code = input.code;
+    this.eventType = input.eventType;
+    this.requestId = input.requestId ?? null;
+    this.diagnosticTruncated = input.diagnosticTruncated === true;
+    this.headers = input.headers ?? new Headers();
+  }
+};
+var XAI_SUBSCRIPTION_RATE_LIMIT_CODES = /* @__PURE__ */ new Set([
+  "rate_limit_exceeded",
+  "too_many_requests",
+  "overloaded_error",
+  "server_overloaded",
+  "capacity_exceeded",
+  "resource_exhausted"
+]);
+var XAI_SUBSCRIPTION_RATE_LIMIT_MESSAGE = /the model is currently at capacity due to high demand/i;
+function isXaiSubscriptionRateLimitDiagnostic(input) {
+  if (input.status === 429) return true;
+  const code = (input.code ?? "").trim().toLowerCase();
+  if (XAI_SUBSCRIPTION_RATE_LIMIT_CODES.has(code)) return true;
+  return XAI_SUBSCRIPTION_RATE_LIMIT_MESSAGE.test(input.message ?? "");
+}
+function classifyXaiSubscriptionStreamingTerminalError(error) {
+  let current = error;
+  for (let depth = 0; depth < 8 && current && typeof current === "object"; depth += 1) {
+    const value = current;
+    if (current instanceof XaiSubscriptionStreamingTerminalError || value.name === "XaiSubscriptionStreamingTerminalError") {
+      const code = typeof value.code === "string" && value.code.length > 0 ? value.code : null;
+      const eventType = typeof value.eventType === "string" && value.eventType.length > 0 ? value.eventType : null;
+      const message = typeof value.message === "string" ? value.message : "";
+      if (!code || !eventType || message.length === 0) return null;
+      const status = Number(value.status);
+      return {
+        message,
+        code,
+        eventType,
+        requestId: typeof value.requestId === "string" ? value.requestId : null,
+        ...Number.isInteger(status) && status >= 100 && status <= 599 ? { status } : {},
+        diagnosticTruncated: value.diagnosticTruncated === true
+      };
+    }
+    current = value.cause;
+  }
+  return null;
+}
+var XaiSubscriptionStreamIdleTimeoutError = class extends XaiSubscriptionError {
+  constructor(requestId, responseObserved, eventCount, lastEventType, silenceDurationMs) {
+    super(
+      "timeout",
+      "SuperGrok stopped sending valid response events. The partial response was preserved and was not replayed automatically."
+    );
+    this.requestId = requestId;
+    this.responseObserved = responseObserved;
+    this.eventCount = eventCount;
+    this.lastEventType = lastEventType;
+    this.silenceDurationMs = silenceDurationMs;
+    this.name = "XaiSubscriptionStreamIdleTimeoutError";
+  }
+  code = "xai_response_stream_idle_timeout";
+};
+function classifyXaiSubscriptionStreamIdleTimeoutError(error) {
+  let current = error;
+  for (let depth = 0; depth < 8 && current && typeof current === "object"; depth += 1) {
+    const value = current;
+    if (current instanceof XaiSubscriptionStreamIdleTimeoutError || value.code === "xai_response_stream_idle_timeout") {
+      return {
+        requestId: typeof value.requestId === "string" ? value.requestId : null,
+        responseObserved: value.responseObserved === true,
+        eventCount: typeof value.eventCount === "number" && Number.isSafeInteger(value.eventCount) ? value.eventCount : 0,
+        lastEventType: typeof value.lastEventType === "string" ? value.lastEventType : null,
+        silenceDurationMs: typeof value.silenceDurationMs === "number" && Number.isFinite(value.silenceDurationMs) ? Math.max(0, value.silenceDurationMs) : 0
+      };
+    }
+    current = value.cause;
+  }
+  return null;
+}
+function isXaiSubscriptionHostedToolContinuationError(error) {
+  let current = error;
+  for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
+    if (current instanceof XaiSubscriptionHostedToolContinuationError) return true;
+    if (current.code === "xai_hosted_tool_continuation_stalled") {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
 
 // src/bounded-operation.ts
 async function runBoundedXaiOperation(operation, timeoutMs) {
@@ -303,6 +411,27 @@ async function fetchXaiVerifiedIdentity(accessToken, options = {}) {
     name: nullableString(body.name)
   };
 }
+function xaiIdentityFromDeviceTokens(tokens) {
+  const accessClaims = decodeXaiJwtPayload(tokens.accessToken);
+  const idClaims = tokens.idToken ? decodeXaiJwtPayload(tokens.idToken) : null;
+  const subject = nullableString(accessClaims?.principal_id) ?? nullableString(accessClaims?.principalId) ?? nullableString(idClaims?.sub) ?? nullableString(accessClaims?.sub);
+  if (!subject) {
+    throw new XaiSubscriptionError(
+      "invalid_response",
+      "xAI OAuth token response is missing account identity"
+    );
+  }
+  const givenName = nullableString(idClaims?.given_name) ?? nullableString(accessClaims?.given_name);
+  const familyName = nullableString(idClaims?.family_name) ?? nullableString(accessClaims?.family_name);
+  const combinedName = [givenName, familyName].filter(Boolean).join(" ") || null;
+  const emailVerifiedClaim = idClaims?.email_verified ?? accessClaims?.email_verified;
+  return {
+    subject,
+    email: nullableString(idClaims?.email) ?? nullableString(accessClaims?.email),
+    emailVerified: typeof emailVerifiedClaim === "boolean" ? emailVerifiedClaim : null,
+    name: nullableString(idClaims?.name) ?? nullableString(accessClaims?.name) ?? combinedName
+  };
+}
 function decodeXaiJwtPayload(jwt) {
   const payload = jwt.split(".")[1];
   if (!payload) return null;
@@ -425,6 +554,17 @@ var XAI_SUBSCRIPTION_REQUEST_BODY_NORMALIZED_HEADER = "x-opengeni-xai-subscripti
 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;
+var MAX_STREAM_IDLE_TIMEOUT_MS = 24 * 60 * 6e4;
+var MAX_TERMINAL_ERROR_FIELD_BYTES = 256;
+var MAX_TERMINAL_ERROR_MESSAGE_BYTES = 4 * 1024;
+var TERMINAL_ERROR_TRUNCATION_MARKER = "\u2026 [truncated]";
+var NON_RETRYABLE_SSE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "context_length_exceeded",
+  "invalid_prompt",
+  "invalid_request",
+  "insufficient_quota",
+  "usage_limit_reached"
+]);
 function xaiSubscriptionFetch(base) {
   return async (input, init) => {
     const context = xaiSubscriptionRequestStorage.getStore();
@@ -439,7 +579,7 @@ function xaiSubscriptionFetch(base) {
       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 requestId = originalHeaders.get(XAI_SUBSCRIPTION_REQUEST_ID_HEADER) ?? context.nextRequestId?.() ?? 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);
@@ -449,7 +589,10 @@ function xaiSubscriptionFetch(base) {
     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 streamIdleTimeoutMs = boundedStreamIdleTimeout(
+      context.streamIdleTimeoutMs ?? context.hostedToolContinuationTimeoutMs
+    );
+    const send = async (refresh, transportAttempt) => {
       const token = refresh ? await context.refresh() : await context.getToken();
       const headers = new Headers(originalHeaders);
       headers.set("authorization", `Bearer ${token.accessToken}`);
@@ -468,19 +611,64 @@ function xaiSubscriptionFetch(base) {
       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)
-      });
+      const audit = {
+        ctx: context,
+        requestId,
+        transportAttempt,
+        model,
+        startedAt: performance.now(),
+        streamIdleTimeoutMs,
+        eventCount: 0,
+        lastEventType: null,
+        lastProgressAt: null,
+        terminal: false,
+        terminalEventEmitted: false
+      };
+      let response;
+      try {
+        await emitRequestEvent(audit, {
+          phase: "started",
+          responseObserved: false
+        });
+        response = await base(url, {
+          ...init,
+          method: init?.method ?? (input instanceof Request ? input.method : "POST"),
+          headers,
+          body: JSON.stringify(normalizedBody)
+        });
+        await emitRequestEvent(audit, {
+          phase: "headers",
+          responseObserved: true,
+          status: response.status,
+          ...providerRequestIdFields(response.headers)
+        });
+        return { response, audit };
+      } catch (error) {
+        await response?.body?.cancel(error).catch(() => void 0);
+        await emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: response !== void 0,
+          ...response ? {
+            status: response.status,
+            ...providerRequestIdFields(response.headers)
+          } : {}
+        }).catch(() => void 0);
+        throw error;
+      }
     };
-    let response = await send(false);
-    if (response.status === 401) {
-      await response.body?.cancel().catch(() => void 0);
-      response = await send(true);
+    let sent = await send(false, 1);
+    if (sent.response.status === 401) {
+      await sent.response.body?.cancel().catch(() => void 0);
+      await emitRequestEvent(sent.audit, {
+        phase: "failed",
+        responseObserved: true,
+        status: sent.response.status,
+        willRetry: true,
+        ...providerRequestIdFields(sent.response.headers)
+      });
+      sent = await send(true, 2);
     }
-    return await normalizeResponse(response, context.onFinalContextUsage);
+    return await normalizeResponse(sent.response, sent.audit, context.onFinalContextUsage);
   };
 }
 async function requestBodyText(input, init, replayableBodyFactory) {
@@ -490,19 +678,33 @@ async function requestBodyText(input, init, replayableBodyFactory) {
   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) {
+async function normalizeResponse(response, audit, 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");
+    await emitRequestEvent(audit, {
+      phase: "failed",
+      responseObserved: true,
+      status: response.status,
+      ...providerRequestIdFields(response.headers)
+    });
     return new Response(bounded, {
       status: response.status,
       statusText: response.statusText,
       headers
     });
   }
-  if (!response.body) return response;
+  if (!response.body) {
+    await emitRequestEvent(audit, {
+      phase: "completed",
+      responseObserved: true,
+      status: response.status,
+      ...providerRequestIdFields(response.headers)
+    });
+    return response;
+  }
   const contentType = response.headers.get("content-type") ?? "";
   if (!contentType.includes("text/event-stream")) {
     const value = await response.json();
@@ -512,6 +714,12 @@ async function normalizeResponse(response, onFinalContextUsage) {
     });
     emitContextUsage(normalized.value, normalized.finalContextTokens, onFinalContextUsage);
     const responseValue = normalized.value && typeof normalized.value === "object" && !Array.isArray(normalized.value) ? normalized.value.response : value;
+    await emitRequestEvent(audit, {
+      phase: "completed",
+      responseObserved: true,
+      status: response.status,
+      ...providerRequestIdFields(response.headers)
+    });
     return Response.json(responseValue, {
       status: response.status,
       statusText: response.statusText,
@@ -522,24 +730,185 @@ async function normalizeResponse(response, onFinalContextUsage) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   let pending = "";
+  let idleTimer = null;
+  let controllerRef = null;
+  let silenceStartedAt = performance.now();
+  let streamSettled = false;
+  const errorStream = (error) => {
+    if (streamSettled || !controllerRef) return;
+    streamSettled = true;
+    controllerRef.error(error);
+  };
+  const closeStream = () => {
+    if (streamSettled || !controllerRef) return;
+    streamSettled = true;
+    controllerRef.close();
+  };
+  const clearIdleTimer = () => {
+    if (idleTimer !== null) clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  const armIdleTimer = () => {
+    clearIdleTimer();
+    idleTimer = setTimeout(() => {
+      if (audit.terminal || !controllerRef) return;
+      audit.terminal = true;
+      clearIdleTimer();
+      const now = performance.now();
+      const silenceDurationMs = Math.max(0, now - silenceStartedAt);
+      const error = new XaiSubscriptionStreamIdleTimeoutError(
+        audit.requestId,
+        audit.eventCount > 0,
+        audit.eventCount,
+        audit.lastEventType,
+        silenceDurationMs
+      );
+      void reader.cancel(error).catch(() => void 0);
+      void emitRequestEvent(audit, {
+        phase: "timed_out",
+        responseObserved: audit.eventCount > 0,
+        status: response.status,
+        silenceDurationMs,
+        ...providerRequestIdFields(response.headers)
+      }).then(
+        () => errorStream(error),
+        () => errorStream(error)
+      );
+    }, audit.streamIdleTimeoutMs);
+    idleTimer.unref?.();
+  };
   const body = new ReadableStream({
+    start(controller) {
+      controllerRef = controller;
+      silenceStartedAt = performance.now();
+      armIdleTimer();
+    },
     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 (audit.terminal) return;
+      try {
+        while (!audit.terminal) {
+          const chunk = await reader.read();
+          if (audit.terminal) return;
+          pending += decoder.decode(chunk.value, { stream: !chunk.done });
+          const parts = pending.split(/\r?\n\r?\n/);
+          pending = parts.pop() ?? "";
+          if (chunk.done && pending) {
+            parts.push(pending);
+            pending = "";
+          }
+          let enqueued = false;
+          for (const part of parts) {
+            const progress = sseProgress(part);
+            if (!progress.valid) {
+              controller.enqueue(
+                encoder.encode(`${normalizeSseEvent(part, onFinalContextUsage)}
+
+`)
+              );
+              enqueued = true;
+              continue;
+            }
+            clearIdleTimer();
+            const now = performance.now();
+            const interEventGapMs = Math.max(0, now - (audit.lastProgressAt ?? audit.startedAt));
+            audit.eventCount = Math.min(Number.MAX_SAFE_INTEGER, audit.eventCount + 1);
+            audit.lastEventType = progress.eventType;
+            audit.lastProgressAt = now;
+            silenceStartedAt = now;
+            if (audit.eventCount === 1) {
+              await emitRequestEvent(audit, {
+                phase: "first_event",
+                responseObserved: true,
+                status: response.status,
+                ...providerRequestIdFields(response.headers)
+              });
+            } else {
+              emitDiagnosticEvent(audit, {
+                phase: "progress",
+                responseObserved: true,
+                status: response.status,
+                interEventGapMs,
+                ...providerRequestIdFields(response.headers)
+              });
+            }
+            if (progress.terminal === "failed") {
+              audit.terminal = true;
+              clearIdleTimer();
+              await reader.cancel().catch(() => void 0);
+              await emitRequestEvent(audit, {
+                phase: "failed",
+                responseObserved: true,
+                status: response.status,
+                ...providerRequestIdFields(response.headers)
+              });
+              errorStream(xaiSseTerminalError(response, audit, progress));
+              return;
+            }
+            controller.enqueue(
+              encoder.encode(`${normalizeSseEvent(part, onFinalContextUsage)}
 
-`));
-      if (chunk.done) {
-        if (pending)
-          controller.enqueue(encoder.encode(normalizeSseEvent(pending, onFinalContextUsage)));
-        controller.close();
+`)
+            );
+            enqueued = true;
+            if (progress.terminal === "completed") {
+              audit.terminal = true;
+              clearIdleTimer();
+              await reader.cancel().catch(() => void 0);
+              await emitRequestEvent(audit, {
+                phase: "completed",
+                responseObserved: true,
+                status: response.status,
+                ...providerRequestIdFields(response.headers)
+              });
+              closeStream();
+              return;
+            }
+            armIdleTimer();
+          }
+          if (chunk.done) {
+            audit.terminal = true;
+            clearIdleTimer();
+            await emitRequestEvent(audit, {
+              phase: "failed",
+              responseObserved: true,
+              status: response.status,
+              ...providerRequestIdFields(response.headers)
+            });
+            closeStream();
+            return;
+          }
+          if (enqueued) return;
+        }
+      } catch (error) {
+        if (audit.terminal) {
+          errorStream(error);
+          return;
+        }
+        audit.terminal = true;
+        clearIdleTimer();
+        await reader.cancel(error).catch(() => void 0);
+        await emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: true,
+          status: response.status,
+          ...providerRequestIdFields(response.headers)
+        }).catch(() => void 0);
+        errorStream(error);
       }
     },
-    cancel(reason) {
-      return reader.cancel(reason);
+    async cancel(reason) {
+      streamSettled = true;
+      if (!audit.terminal) {
+        audit.terminal = true;
+        clearIdleTimer();
+        await emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: true,
+          status: response.status,
+          ...providerRequestIdFields(response.headers)
+        }).catch(() => void 0);
+      }
+      await reader.cancel(reason).catch(() => void 0);
     }
   });
   return new Response(body, {
@@ -548,11 +917,155 @@ async function normalizeResponse(response, onFinalContextUsage) {
     headers: response.headers
   });
 }
+function sseProgress(block) {
+  for (const line of block.split("\n")) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice(5).trim();
+    if (!data) continue;
+    if (data === "[DONE]") {
+      return { valid: true, eventType: "done", terminal: "completed", payload: null };
+    }
+    try {
+      const parsed = JSON.parse(data);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { valid: false, eventType: null, terminal: null, payload: null };
+      }
+      const payload = parsed;
+      const rawType = payload.type;
+      if (typeof rawType !== "string" || !/^[a-z0-9_.-]{1,96}$/i.test(rawType)) {
+        return { valid: false, eventType: null, terminal: null, payload: null };
+      }
+      const type = rawType;
+      if (type === "response.completed") {
+        return { valid: true, eventType: type, terminal: "completed", payload };
+      }
+      if (type === "error" || type === "response.incomplete" || type === "response.failed" || type === "response.error") {
+        return { valid: true, eventType: type, terminal: "failed", payload };
+      }
+      return { valid: true, eventType: type, terminal: null, payload };
+    } catch {
+      return { valid: false, eventType: null, terminal: null, payload: null };
+    }
+  }
+  return { valid: false, eventType: null, terminal: null, payload: null };
+}
+function boundedTerminalErrorField(value, maxBytes) {
+  if (typeof value !== "string") return { truncated: false };
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(value);
+  if (encoded.byteLength <= maxBytes) return { value, truncated: false };
+  const markerBytes = encoder.encode(TERMINAL_ERROR_TRUNCATION_MARKER).byteLength;
+  let prefixEnd = Math.max(0, maxBytes - markerBytes);
+  while (prefixEnd > 0 && (encoded[prefixEnd] & 192) === 128) {
+    prefixEnd -= 1;
+  }
+  return {
+    value: `${new TextDecoder().decode(encoded.subarray(0, prefixEnd))}${TERMINAL_ERROR_TRUNCATION_MARKER}`,
+    truncated: true
+  };
+}
+function terminalErrorSource(payload, eventType) {
+  if (!payload) return null;
+  if (eventType === "error" || eventType === "response.error") {
+    return payload.error ?? payload;
+  }
+  const response = payload.response;
+  if (response && typeof response === "object" && !Array.isArray(response)) {
+    const nested = response.error;
+    if (nested !== void 0 && nested !== null) return nested;
+  }
+  return payload.error ?? payload;
+}
+function xaiSseTerminalError(source, audit, progress) {
+  const rawError = terminalErrorSource(progress.payload, progress.eventType);
+  const record2 = rawError && typeof rawError === "object" && !Array.isArray(rawError) ? rawError : {};
+  const eventTypeField = boundedTerminalErrorField(
+    progress.eventType,
+    MAX_TERMINAL_ERROR_FIELD_BYTES
+  );
+  const rawCode = record2.code ?? (typeof record2.type === "string" && record2.type !== eventTypeField.value && record2.type !== "error" ? record2.type : void 0);
+  const codeField = boundedTerminalErrorField(rawCode, MAX_TERMINAL_ERROR_FIELD_BYTES);
+  const messageField = boundedTerminalErrorField(
+    record2.message ?? (typeof rawError === "string" ? rawError : void 0),
+    MAX_TERMINAL_ERROR_MESSAGE_BYTES
+  );
+  const eventType = eventTypeField.value ?? "error";
+  const fallbackCode = eventType === "response.failed" ? "response_failed" : eventType === "response.incomplete" ? "response_incomplete" : "response_error";
+  const fallbackMessage = eventType === "response.incomplete" ? "The SuperGrok response was incomplete" : eventType === "response.failed" ? "The SuperGrok response failed" : "The SuperGrok response stream reported an error";
+  const message = messageField.value?.length ? messageField.value : fallbackMessage;
+  let code = codeField.value?.length ? codeField.value : fallbackCode;
+  const rateLimited = !NON_RETRYABLE_SSE_ERROR_CODES.has(code) && isXaiSubscriptionRateLimitDiagnostic({ code, message });
+  if (rateLimited && (code === fallbackCode || code === "response_error")) {
+    code = "rate_limit_exceeded";
+  }
+  const status = rateLimited ? 429 : NON_RETRYABLE_SSE_ERROR_CODES.has(code) ? 400 : 502;
+  const headers = new Headers(source.headers);
+  headers.set("content-type", "application/json");
+  headers.set(XAI_SUBSCRIPTION_TRANSPORT_ERROR_HEADER, "1");
+  headers.set("x-should-retry", "false");
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  return new XaiSubscriptionStreamingTerminalError({
+    message,
+    code,
+    eventType,
+    requestId: audit.requestId,
+    status,
+    diagnosticTruncated: eventTypeField.truncated || codeField.truncated || messageField.truncated,
+    headers
+  });
+}
+function boundedStreamIdleTimeout(value) {
+  const resolved = value ?? XAI_RESPONSE_STREAM_IDLE_TIMEOUT_MS;
+  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > MAX_STREAM_IDLE_TIMEOUT_MS) {
+    throw new RangeError("SuperGrok response stream idle timeout is invalid");
+  }
+  return resolved;
+}
+function providerRequestId(headers) {
+  return headers.get("x-request-id") ?? headers.get("request-id") ?? void 0;
+}
+function providerRequestIdFields(headers) {
+  const value = providerRequestId(headers);
+  return value ? { providerRequestId: value } : {};
+}
+function requestEventFor(audit, event) {
+  const now = performance.now();
+  return {
+    requestId: audit.requestId,
+    transportAttempt: audit.transportAttempt,
+    model: audit.model,
+    durationMs: Math.max(0, now - audit.startedAt),
+    streamIdleTimeoutMs: audit.streamIdleTimeoutMs,
+    eventCount: audit.eventCount,
+    ...audit.lastEventType ? { lastEventType: audit.lastEventType } : {},
+    ...audit.lastProgressAt !== null ? {
+      lastProgressDurationMs: Math.max(0, audit.lastProgressAt - audit.startedAt)
+    } : {},
+    ...event
+  };
+}
+function emitDiagnosticEvent(audit, event) {
+  const observed = requestEventFor(audit, event);
+  try {
+    audit.ctx.onModelRequestDiagnostic?.(observed);
+  } catch {
+  }
+  return observed;
+}
+async function emitRequestEvent(audit, event) {
+  if (event.phase === "completed" || event.phase === "failed" || event.phase === "timed_out") {
+    if (audit.terminalEventEmitted) return;
+    audit.terminalEventEmitted = true;
+  }
+  const observed = emitDiagnosticEvent(audit, event);
+  await audit.ctx.onModelRequestEvent?.(observed);
+}
 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();
+    const data = line.slice(5).trim();
     if (!data || data === "[DONE]") return line;
     try {
       const normalized = normalizeXaiResponseEventJson(JSON.parse(data));
@@ -580,6 +1093,7 @@ function emitContextUsage(value, finalContextTokens, sink) {
 function isXaiSubscriptionTransportError(error) {
   let current = error;
   for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
+    if (current instanceof XaiSubscriptionStreamingTerminalError) return true;
     const value = current;
     const headers = value.headers;
     if (headers && typeof headers === "object" && typeof headers.get === "function" && headers.get(XAI_SUBSCRIPTION_TRANSPORT_ERROR_HEADER) === "1") {
@@ -1195,6 +1709,7 @@ export {
   XAI_REFRESH_FALLBACK_MS,
   XAI_REFRESH_WINDOW_MS,
   XAI_RESPONSE_SDK_OUTER_TIMEOUT_MS,
+  XAI_RESPONSE_STREAM_IDLE_TIMEOUT_MS,
   XAI_SUBSCRIPTION_AUTO_COMPACTION_PERCENT,
   XAI_SUBSCRIPTION_EFFECTIVE_CONTEXT_PERCENT,
   XAI_SUBSCRIPTION_MODEL_AUTO_COMPACT_TOKEN_LIMIT,
@@ -1218,8 +1733,13 @@ export {
   XAI_VIDEO_POLL_REQUEST_TIMEOUT_MS,
   XAI_VIDEO_START_TIMEOUT_MS,
   XaiSubscriptionError,
+  XaiSubscriptionHostedToolContinuationError,
   XaiSubscriptionReloginRequired,
+  XaiSubscriptionStreamIdleTimeoutError,
+  XaiSubscriptionStreamingTerminalError,
   XaiSubscriptionTransientError,
+  classifyXaiSubscriptionStreamIdleTimeoutError,
+  classifyXaiSubscriptionStreamingTerminalError,
   decodeXaiJwtPayload,
   fetchXaiProxyJson,
   fetchXaiSubscriptionModels,
@@ -1228,6 +1748,8 @@ export {
   generateXaiSubscriptionImage,
   generateXaiSubscriptionVideo,
   getXaiSubscriptionVideoStatus,
+  isXaiSubscriptionHostedToolContinuationError,
+  isXaiSubscriptionRateLimitDiagnostic,
   isXaiSubscriptionTransportError,
   normalizeXaiResponseEventJson,
   normalizeXaiSubscriptionRequestBody,
@@ -1238,6 +1760,7 @@ export {
   runBoundedXaiOperation,
   startXaiSubscriptionVideoWithBody,
   xaiAccessTokenExpiry,
+  xaiIdentityFromDeviceTokens,
   xaiSubscriptionFetch,
   xaiSubscriptionProxyHeaders,
   xaiSubscriptionRequestStorage