@gullabs/xai 0.2.5 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AuthMaterial, LlmError, ProviderAdapter, ModelDescriptor, ModelRegistry, Usage, Cost, PricingSource, ProviderPlugin } from '@gullabs/core';
+import { AuthMaterial, LlmError, ProviderAdapter, JsonValue, Logger, ModelDescriptor, ModelRegistry, Usage, Cost, PricingSource, ProviderPlugin } from '@gullabs/core';
 import { z } from 'zod';
 
 /**
@@ -55,8 +55,19 @@ interface XaiInputImagePart {
     type: 'input_image';
     image_url: string;
 }
+/**
+ * A file attachment content item within an xAI Responses API input message.
+ * Prefer `file_id` for private uploads (via {@link XaiFileStore}); `file_url`
+ * is for publicly reachable documents. Attaching either implicitly enables
+ * xAI's `attachment_search` agentic tool.
+ */
+interface XaiInputFilePart {
+    type: 'input_file';
+    file_id?: string;
+    file_url?: string;
+}
 /** Union of content-part shapes an input message may carry. */
-type XaiInputContentPart = XaiInputTextPart | XaiInputImagePart;
+type XaiInputContentPart = XaiInputTextPart | XaiInputImagePart | XaiInputFilePart;
 /** A single role+content input item constructed by the (future) adapter. */
 interface XaiInputItem {
     role: 'user' | 'assistant' | 'system' | 'developer';
@@ -267,6 +278,120 @@ interface XaiAdapterOptions {
  */
 declare function xaiAdapter(opts?: XaiAdapterOptions): ProviderAdapter;
 
+/**
+ * XaiFileStore — thin wrapper over the xAI Files REST API.
+ *
+ * Upload / get / list / delete / content over injectable `fetch`.
+ * No READY-state polling (upload returns metadata immediately).
+ * No ambient credential reads — auth is injected at construction.
+ *
+ * @module
+ */
+
+/** xAI minimum `expires_after` (1 hour), inclusive. */
+declare const XAI_FILE_TTL_MIN_SECONDS = 3600;
+/** xAI maximum `expires_after` (30 days), inclusive. */
+declare const XAI_FILE_TTL_MAX_SECONDS = 2592000;
+/**
+ * Conservative max upload size (48 MiB). Managing-files docs say ~48 MB;
+ * upload REST says 50 MB — we take the lower bound.
+ */
+declare const XAI_FILE_MAX_BYTES: number;
+/** Default Files API base (includes `/v1`). */
+declare const XAI_FILES_DEFAULT_BASE_URL = "https://api.x.ai/v1";
+/** A handle to a file stored in the xAI Files API. */
+interface XaiFileHandle {
+    /** File id, e.g. `"file_a128090d-…"`. Use as `FileRefPart.fileId`. */
+    id: string;
+    filename?: string;
+    bytes?: number;
+    purpose?: string;
+    createdAt?: Date;
+    /** Present when the file has a TTL; key omitted when permanent / unknown. */
+    expiresAt?: Date;
+    /** Full vendor JSON object for forward-compat (P2 raw lane). */
+    raw?: {
+        [k: string]: JsonValue;
+    };
+}
+interface XaiFileUploadInput {
+    data: Uint8Array | Blob;
+    filename: string;
+    mimeType?: string;
+    /**
+     * TTL in seconds. Must be an integer in
+     * `[XAI_FILE_TTL_MIN_SECONDS, XAI_FILE_TTL_MAX_SECONDS]` when set.
+     * Omit only for permanent storage (discouraged for ephemeral corpus).
+     */
+    expiresAfterSeconds?: number;
+    /** Default `"assistants"` (OpenAI SDK convention; xAI does not enforce). */
+    purpose?: string;
+}
+interface XaiFileListOptions {
+    /** 1..100. Server default is 100 when omitted. */
+    limit?: number;
+    order?: 'asc' | 'desc';
+    sortBy?: 'created_at' | 'filename' | 'size';
+    paginationToken?: string;
+}
+interface XaiFileListResult {
+    files: XaiFileHandle[];
+    paginationToken?: string;
+}
+interface XaiFileStoreOptions {
+    auth: AuthMaterial;
+    /** Default {@link XAI_FILES_DEFAULT_BASE_URL}. */
+    baseUrl?: string;
+    /** Injectable fetch for tests. Default: global `fetch`. */
+    fetch?: typeof fetch;
+    /**
+     * Delete failures that are NOT already-gone (404).
+     * Default: `logger.error` or `console.error` with a redacted message.
+     */
+    onDeleteError?: (fileId: string, err: unknown) => void;
+    logger?: Logger;
+    /** Injectable clock for tests. Default: `Date.now`. */
+    now?: () => number;
+}
+/**
+ * **Auth snapshot note:** captures `AuthMaterial` at construction and holds
+ * the resolved API key for the store lifetime. Correct for static API keys.
+ * Refreshable credentials would need a resolver callback (see GoogleFileStore
+ * / ADR-020).
+ */
+declare class XaiFileStore {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly onDeleteError;
+    private readonly logger;
+    constructor(opts: XaiFileStoreOptions);
+    private authHeaders;
+    private filesUrl;
+    /** Build RequestInit without writing `signal: undefined` (exactOptionalPropertyTypes). */
+    private requestInit;
+    /**
+     * Upload bytes to xAI Files. Returns immediately with metadata (no poll).
+     *
+     * Multipart field order is load-bearing: `expires_after` then `purpose`
+     * then `file` — reversing order yields HTTP 400 from xAI.
+     */
+    upload(input: XaiFileUploadInput, signal?: AbortSignal): Promise<XaiFileHandle>;
+    get(fileId: string, signal?: AbortSignal): Promise<XaiFileHandle>;
+    list(opts?: XaiFileListOptions, signal?: AbortSignal): Promise<XaiFileListResult>;
+    /**
+     * Delete a file. Idempotent: HTTP 404 → success.
+     * Other errors are forwarded to `onDeleteError` and **not** rethrown (P5).
+     */
+    delete(fileIdOrHandle: string | Pick<XaiFileHandle, 'id'>, signal?: AbortSignal): Promise<void>;
+    /**
+     * Delete many files. Each failure is individually fail-open; none are thrown.
+     */
+    deleteAll(ids: ReadonlyArray<string | Pick<XaiFileHandle, 'id'>>, signal?: AbortSignal): Promise<void>;
+    /** Download raw file bytes. */
+    getContent(fileId: string, signal?: AbortSignal): Promise<Uint8Array>;
+}
+
 /**
  * Strict Zod config schema for xAI's `grok-4.5` model.
  *
@@ -441,4 +566,4 @@ declare function xaiPricingSource(): PricingSource;
  */
 declare function xaiProvider(opts?: XaiAdapterOptions): ProviderPlugin;
 
-export { Grok45ConfigSchema, XAI_PRICING, type XaiAdapterOptions, type XaiClientLike, type XaiInputContentPart, type XaiInputImagePart, type XaiInputItem, type XaiInputTextPart, type XaiMessageOutputItem, type XaiModelRates, type XaiOutputItem, type XaiOutputTextPart, type XaiProviderOptions, type XaiReasoningOutputItem, type XaiReasoningSummaryPart, type XaiResponseCreateParams, type XaiResponseShape, type XaiTextFormat, type XaiUsageShape, buildXaiClient, classifyXaiError, computeXaiCost, grok45ModelDescriptor, requireApiKey, xaiAdapter, xaiModelDescriptors, xaiPricingSource, xaiPricingVersion, xaiProvider, xaiRegistry };
+export { Grok45ConfigSchema, XAI_FILES_DEFAULT_BASE_URL, XAI_FILE_MAX_BYTES, XAI_FILE_TTL_MAX_SECONDS, XAI_FILE_TTL_MIN_SECONDS, XAI_PRICING, type XaiAdapterOptions, type XaiClientLike, type XaiFileHandle, type XaiFileListOptions, type XaiFileListResult, XaiFileStore, type XaiFileStoreOptions, type XaiFileUploadInput, type XaiInputContentPart, type XaiInputFilePart, type XaiInputImagePart, type XaiInputItem, type XaiInputTextPart, type XaiMessageOutputItem, type XaiModelRates, type XaiOutputItem, type XaiOutputTextPart, type XaiProviderOptions, type XaiReasoningOutputItem, type XaiReasoningSummaryPart, type XaiResponseCreateParams, type XaiResponseShape, type XaiTextFormat, type XaiUsageShape, buildXaiClient, classifyXaiError, computeXaiCost, grok45ModelDescriptor, requireApiKey, xaiAdapter, xaiModelDescriptors, xaiPricingSource, xaiPricingVersion, xaiProvider, xaiRegistry };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { zodToStandardSchema, toConfigJsonSchema, createModelRegistry, LlmError, classifyError, assertNever } from '@gullabs/core';
+import { zodToStandardSchema, toConfigJsonSchema, createModelRegistry, LlmError, classifyError, redactSecrets, assertNever } from '@gullabs/core';
 import { z } from 'zod';
 
 // src/client.ts
@@ -62,8 +62,19 @@ function mapPart(p) {
           `xAI only accepts public http(s) image URLs via FileUriPart; got scheme of "${p.uri}" / mimeType "${p.mimeType}".`
         );
       }
+      if (p.uri.includes("generativelanguage.googleapis.com") || p.uri.includes("googleapis.com/v1beta/files")) {
+        throw badXaiRequest(
+          `xAI cannot dereference Gemini/Google Files URIs via FileUriPart; upload to xAI Files and use FileRefPart (file_id) instead. Got "${p.uri}".`
+        );
+      }
       return { type: "input_image", image_url: p.uri };
     }
+    case "file-ref": {
+      if (typeof p.fileId !== "string" || p.fileId.trim() === "") {
+        throw badXaiRequest("FileRefPart.fileId must be a non-empty string.");
+      }
+      return { type: "input_file", file_id: p.fileId };
+    }
     default:
       return assertNever(p);
   }
@@ -362,6 +373,453 @@ function xaiAdapter(opts) {
     }
   };
 }
+var XAI_FILE_TTL_MIN_SECONDS = 3600;
+var XAI_FILE_TTL_MAX_SECONDS = 2592e3;
+var XAI_FILE_MAX_BYTES = 48 * 1024 * 1024;
+var XAI_FILES_DEFAULT_BASE_URL = "https://api.x.ai/v1";
+function isPlainRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function badRequest(message) {
+  return new LlmError(message, {
+    kind: "bad_request",
+    retryable: false,
+    provider: "xai"
+  });
+}
+function resolveFileId(fileIdOrHandle) {
+  if (typeof fileIdOrHandle === "string") {
+    return fileIdOrHandle;
+  }
+  return fileIdOrHandle.id;
+}
+function unixSecondsToDate(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return new Date(value * 1e3);
+}
+function makeHandle(raw) {
+  if (typeof raw.id !== "string" || raw.id.length === 0) {
+    throw new LlmError("File response missing required field (id)", {
+      kind: "server",
+      retryable: false,
+      provider: "xai"
+    });
+  }
+  const handle = {
+    id: raw.id,
+    raw
+  };
+  if (typeof raw.filename === "string" && raw.filename.length > 0) {
+    handle.filename = raw.filename;
+  }
+  if (typeof raw.bytes === "number" && Number.isFinite(raw.bytes)) {
+    handle.bytes = raw.bytes;
+  }
+  if (typeof raw.purpose === "string") {
+    handle.purpose = raw.purpose;
+  }
+  const createdAt = unixSecondsToDate(raw.created_at);
+  if (createdAt !== void 0) {
+    handle.createdAt = createdAt;
+  }
+  if (raw.expires_at !== null && raw.expires_at !== void 0) {
+    const expiresAt = unixSecondsToDate(raw.expires_at);
+    if (expiresAt !== void 0) {
+      handle.expiresAt = expiresAt;
+    }
+  }
+  return handle;
+}
+function byteLengthOf(data) {
+  return data instanceof Uint8Array ? data.byteLength : data.size;
+}
+function toBlob(data, mimeType) {
+  if (data instanceof Blob) {
+    return data;
+  }
+  const copy = Uint8Array.from(data);
+  return mimeType !== void 0 && mimeType.length > 0 ? new Blob([copy], { type: mimeType }) : new Blob([copy]);
+}
+var XaiFilesHttpError = class extends Error {
+  status;
+  error;
+  constructor(status, message, errorBody) {
+    super(message);
+    this.name = "XaiFilesHttpError";
+    this.status = status;
+    this.error = errorBody;
+  }
+};
+async function throwHttpFailure(res) {
+  const status = res.status;
+  let bodyText = "";
+  try {
+    bodyText = await res.text();
+  } catch {
+    bodyText = "";
+  }
+  let parsed = bodyText;
+  if (bodyText.length > 0) {
+    try {
+      parsed = JSON.parse(bodyText);
+    } catch {
+      parsed = bodyText;
+    }
+  }
+  let message = `xAI Files API HTTP ${status}`;
+  if (typeof parsed === "string" && parsed.length > 0) {
+    message = parsed;
+  } else if (isPlainRecord2(parsed) && typeof parsed["error"] === "string") {
+    message = parsed["error"];
+  }
+  throw new XaiFilesHttpError(status, message, parsed);
+}
+function isNotFoundError(err) {
+  if (err instanceof LlmError && err.httpStatus === 404) {
+    return true;
+  }
+  if (typeof err === "object" && err !== null) {
+    const status = err.status;
+    if (status === 404) return true;
+    const httpStatus = err.httpStatus;
+    if (httpStatus === 404) return true;
+  }
+  return false;
+}
+function notFoundError(fileId, operation) {
+  return new LlmError(`xAI file not found during ${operation}: "${fileId}"`, {
+    kind: "bad_request",
+    retryable: false,
+    httpStatus: 404,
+    provider: "xai"
+  });
+}
+function maybeZdrHint(message) {
+  if (/zero\s*data\s*retention|\bzdr\b|files?\s+(api\s+)?(disabled|unavailable|not supported)/i.test(
+    message
+  )) {
+    return `${message} (xAI Zero Data Retention blocks new file uploads and file_id attachments for this team.)`;
+  }
+  return message;
+}
+function extractThrownMessage(raw) {
+  if (raw === null || typeof raw !== "object") return void 0;
+  const obj = raw;
+  if (typeof obj["message"] === "string" && obj["message"].length > 0) {
+    return obj["message"];
+  }
+  const err = obj["error"];
+  if (typeof err === "string" && err.length > 0) return err;
+  if (typeof err === "object" && err !== null) {
+    const nested = err;
+    if (typeof nested["error"] === "string" && nested["error"].length > 0) {
+      return nested["error"];
+    }
+    if (typeof nested["message"] === "string" && nested["message"].length > 0) {
+      return nested["message"];
+    }
+  }
+  return void 0;
+}
+function classifyStoreError(raw) {
+  if (raw instanceof LlmError) {
+    return raw;
+  }
+  const classified = classifyXaiError(raw);
+  const bodyMessage = extractThrownMessage(raw);
+  const baseMessage = bodyMessage !== void 0 && (classified.message.startsWith("HTTP ") || classified.message.length === 0) ? bodyMessage : classified.message;
+  const hinted = maybeZdrHint(baseMessage);
+  if (hinted === classified.message && classified.provider === "xai" && bodyMessage === void 0) {
+    return classified;
+  }
+  return new LlmError(hinted, {
+    kind: classified.kind,
+    retryable: classified.retryable,
+    ...classified.httpStatus !== void 0 ? { httpStatus: classified.httpStatus } : {},
+    ...classified.retryAfterMs !== void 0 ? { retryAfterMs: classified.retryAfterMs } : {},
+    provider: "xai",
+    cause: classified.cause ?? raw
+  });
+}
+var XaiFileStore = class {
+  apiKey;
+  baseUrl;
+  fetchImpl;
+  onDeleteError;
+  logger;
+  constructor(opts) {
+    this.apiKey = requireApiKey(opts.auth);
+    this.baseUrl = (opts.baseUrl ?? XAI_FILES_DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? fetch;
+    this.logger = opts.logger;
+    this.onDeleteError = opts.onDeleteError ?? ((fileId, err) => {
+      const message = redactSecrets(classifyError(err).message);
+      if (this.logger !== void 0) {
+        this.logger.error({ fileId, error: message }, "xai.file.delete.failed");
+      } else {
+        console.error(`[XaiFileStore] delete failed for "${fileId}":`, message);
+      }
+    });
+  }
+  authHeaders() {
+    const headers = new Headers();
+    headers.set("Authorization", `Bearer ${this.apiKey}`);
+    return headers;
+  }
+  filesUrl(path = "") {
+    if (path.length === 0) return `${this.baseUrl}/files`;
+    return `${this.baseUrl}/files/${path.replace(/^\//, "")}`;
+  }
+  /** Build RequestInit without writing `signal: undefined` (exactOptionalPropertyTypes). */
+  requestInit(method, opts) {
+    const init = {
+      method,
+      headers: this.authHeaders()
+    };
+    if (opts?.body !== void 0) {
+      init.body = opts.body;
+    }
+    if (opts?.signal !== void 0) {
+      init.signal = opts.signal;
+    }
+    return init;
+  }
+  /**
+   * Upload bytes to xAI Files. Returns immediately with metadata (no poll).
+   *
+   * Multipart field order is load-bearing: `expires_after` then `purpose`
+   * then `file` — reversing order yields HTTP 400 from xAI.
+   */
+  async upload(input, signal) {
+    if (typeof input.filename !== "string" || input.filename.trim() === "") {
+      throw badRequest("XaiFileUploadInput.filename must be a non-empty string.");
+    }
+    const size = byteLengthOf(input.data);
+    if (size > XAI_FILE_MAX_BYTES) {
+      throw badRequest(
+        `xAI file uploads must be at most ${XAI_FILE_MAX_BYTES} bytes (48 MiB); got ${size}.`
+      );
+    }
+    if (input.expiresAfterSeconds !== void 0) {
+      const ttl = input.expiresAfterSeconds;
+      if (typeof ttl !== "number" || !Number.isInteger(ttl) || ttl < XAI_FILE_TTL_MIN_SECONDS || ttl > XAI_FILE_TTL_MAX_SECONDS) {
+        throw badRequest(
+          `expiresAfterSeconds must be an integer in [${XAI_FILE_TTL_MIN_SECONDS}, ${XAI_FILE_TTL_MAX_SECONDS}]; got ${String(ttl)}.`
+        );
+      }
+    }
+    const purpose = input.purpose ?? "assistants";
+    const form = new FormData();
+    if (input.expiresAfterSeconds !== void 0) {
+      form.append("expires_after", String(input.expiresAfterSeconds));
+    }
+    form.append("purpose", purpose);
+    form.append("file", toBlob(input.data, input.mimeType), input.filename);
+    let res;
+    try {
+      res = await this.fetchImpl(
+        this.filesUrl(),
+        this.requestInit("POST", {
+          body: form,
+          ...signal !== void 0 ? { signal } : {}
+        })
+      );
+    } catch (e) {
+      if (signal?.aborted === true) {
+        throw new LlmError("xAI file upload aborted", {
+          kind: "aborted",
+          retryable: false,
+          provider: "xai"
+        });
+      }
+      throw classifyStoreError(e);
+    }
+    if (!res.ok) {
+      try {
+        await throwHttpFailure(res);
+      } catch (e) {
+        throw classifyStoreError(e);
+      }
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch (e) {
+      throw new LlmError("xAI file upload returned non-JSON body", {
+        kind: "server",
+        retryable: false,
+        provider: "xai",
+        cause: e
+      });
+    }
+    return makeHandle(json);
+  }
+  async get(fileId, signal) {
+    if (typeof fileId !== "string" || fileId.trim() === "") {
+      throw badRequest("fileId must be a non-empty string.");
+    }
+    let res;
+    try {
+      res = await this.fetchImpl(
+        this.filesUrl(fileId),
+        this.requestInit("GET", signal !== void 0 ? { signal } : {})
+      );
+    } catch (e) {
+      if (signal?.aborted === true) {
+        throw new LlmError("xAI file get aborted", {
+          kind: "aborted",
+          retryable: false,
+          provider: "xai"
+        });
+      }
+      throw classifyStoreError(e);
+    }
+    if (res.status === 404) {
+      throw notFoundError(fileId, "get");
+    }
+    if (!res.ok) {
+      try {
+        await throwHttpFailure(res);
+      } catch (e) {
+        throw classifyStoreError(e);
+      }
+    }
+    const json = await res.json();
+    return makeHandle(json);
+  }
+  async list(opts = {}, signal) {
+    if (opts.limit !== void 0) {
+      if (typeof opts.limit !== "number" || !Number.isInteger(opts.limit) || opts.limit < 1 || opts.limit > 100) {
+        throw badRequest("list.limit must be an integer in [1, 100].");
+      }
+    }
+    const params = new URLSearchParams();
+    if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+    if (opts.order !== void 0) params.set("order", opts.order);
+    if (opts.sortBy !== void 0) params.set("sort_by", opts.sortBy);
+    if (opts.paginationToken !== void 0) {
+      params.set("pagination_token", opts.paginationToken);
+    }
+    const qs = params.toString();
+    const url = qs.length > 0 ? `${this.filesUrl()}?${qs}` : this.filesUrl();
+    let res;
+    try {
+      res = await this.fetchImpl(
+        url,
+        this.requestInit("GET", signal !== void 0 ? { signal } : {})
+      );
+    } catch (e) {
+      if (signal?.aborted === true) {
+        throw new LlmError("xAI file list aborted", {
+          kind: "aborted",
+          retryable: false,
+          provider: "xai"
+        });
+      }
+      throw classifyStoreError(e);
+    }
+    if (!res.ok) {
+      try {
+        await throwHttpFailure(res);
+      } catch (e) {
+        throw classifyStoreError(e);
+      }
+    }
+    const json = await res.json();
+    const files = Array.isArray(json.data) ? json.data.map((f) => makeHandle(f)) : [];
+    const result = { files };
+    if (typeof json.pagination_token === "string" && json.pagination_token.length > 0) {
+      result.paginationToken = json.pagination_token;
+    }
+    return result;
+  }
+  /**
+   * Delete a file. Idempotent: HTTP 404 → success.
+   * Other errors are forwarded to `onDeleteError` and **not** rethrown (P5).
+   */
+  async delete(fileIdOrHandle, signal) {
+    const fileId = resolveFileId(fileIdOrHandle);
+    if (typeof fileId !== "string" || fileId.trim() === "") {
+      this.onDeleteError(String(fileId), badRequest("fileId must be a non-empty string."));
+      return;
+    }
+    try {
+      let res;
+      try {
+        res = await this.fetchImpl(
+          this.filesUrl(fileId),
+          this.requestInit("DELETE", signal !== void 0 ? { signal } : {})
+        );
+      } catch (e) {
+        if (signal?.aborted === true) {
+          this.onDeleteError(
+            fileId,
+            new LlmError("xAI file delete aborted", {
+              kind: "aborted",
+              retryable: false,
+              provider: "xai"
+            })
+          );
+          return;
+        }
+        throw e;
+      }
+      if (res.status === 404) {
+        return;
+      }
+      if (!res.ok) {
+        await throwHttpFailure(res);
+      }
+    } catch (err) {
+      if (isNotFoundError(err)) {
+        return;
+      }
+      this.onDeleteError(fileId, classifyStoreError(err));
+    }
+  }
+  /**
+   * Delete many files. Each failure is individually fail-open; none are thrown.
+   */
+  async deleteAll(ids, signal) {
+    await Promise.allSettled(ids.map((id) => this.delete(id, signal)));
+  }
+  /** Download raw file bytes. */
+  async getContent(fileId, signal) {
+    if (typeof fileId !== "string" || fileId.trim() === "") {
+      throw badRequest("fileId must be a non-empty string.");
+    }
+    let res;
+    try {
+      res = await this.fetchImpl(
+        this.filesUrl(`${fileId}/content`),
+        this.requestInit("GET", signal !== void 0 ? { signal } : {})
+      );
+    } catch (e) {
+      if (signal?.aborted === true) {
+        throw new LlmError("xAI file content download aborted", {
+          kind: "aborted",
+          retryable: false,
+          provider: "xai"
+        });
+      }
+      throw classifyStoreError(e);
+    }
+    if (res.status === 404) {
+      throw notFoundError(fileId, "getContent");
+    }
+    if (!res.ok) {
+      try {
+        await throwHttpFailure(res);
+      } catch (e) {
+        throw classifyStoreError(e);
+      }
+    }
+    const buf = await res.arrayBuffer();
+    return new Uint8Array(buf);
+  }
+};
 var Grok45ConfigSchema = z.strictObject({
   temperature: z.number().optional().meta({
     title: "Temperature",
@@ -527,6 +985,6 @@ function xaiProvider(opts) {
   };
 }
 
-export { Grok45ConfigSchema, XAI_PRICING, buildXaiClient, classifyXaiError, computeXaiCost, grok45ModelDescriptor, requireApiKey, xaiAdapter, xaiModelDescriptors, xaiPricingSource, xaiPricingVersion, xaiProvider, xaiRegistry };
+export { Grok45ConfigSchema, XAI_FILES_DEFAULT_BASE_URL, XAI_FILE_MAX_BYTES, XAI_FILE_TTL_MAX_SECONDS, XAI_FILE_TTL_MIN_SECONDS, XAI_PRICING, XaiFileStore, buildXaiClient, classifyXaiError, computeXaiCost, grok45ModelDescriptor, requireApiKey, xaiAdapter, xaiModelDescriptors, xaiPricingSource, xaiPricingVersion, xaiProvider, xaiRegistry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map