@arnilo/prism-provider-xai 0.2.9

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## [0.2.8] - 2026-08-19
+
+### Added
+
+- Initial `@arnilo/prism-provider-xai` (plan 029 Task 4): Chat Completions at `https://api.x.ai/v1`, featured `grok-4.6` / `grok-4.3` / `grok-build-0.1`, sanitized `x-grok-conv-id`, reasoning replay, SuperGrok RFC 8628 device-code OAuth, caller-gated `listXaiModels`.
+
+## [0.1.0] - 2026-08-09
+
+### Changed
+- Released with exact 0.1.0 graph.
+
+## [0.0.28] - 2026-08-08
+
+### Changed
+- Released with exact 0.0.28 graph.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prism contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @arnilo/prism-provider-xai
+
+xAI Grok Chat Completions provider for Prism. API key **or** SuperGrok / X Premium OAuth.
+
+```ts
+import { createXaiOAuthProvider, createXaiProviderPackage } from "@arnilo/prism-provider-xai";
+import { refreshOAuthCredential } from "@arnilo/prism";
+
+api.registerProviderPackage(createXaiProviderPackage({ apiKey: "fake-xai-key" }));
+
+const oauth = createXaiOAuthProvider();
+const creds = await oauth.login({
+  onDeviceCode: ({ userCode, verificationUri }) => {
+    console.log(`Open ${verificationUri} and enter ${userCode}`);
+  },
+});
+await store.set("xai", creds);
+
+api.registerProviderPackage(
+  createXaiProviderPackage({
+    apiKey: async () => {
+      const current = await store.get("xai");
+      return (await refreshOAuthCredential({ provider: oauth, credentials: current, store })).access;
+    },
+  }),
+);
+```
+
+Default OAuth client id `b1a00492-073a-47ea-816f-4c329264a828` is the published Grok CLI public client, not a secret. Hosts may override `clientId`. No PKCE loopback. No `~/.grok` scan.
+
+Cache: sanitized `x-grok-conv-id` from `cache.key ?? cacheKey ?? sessionId`. Thinking on reasoning models is replayed as `reasoning_content`.

package/dist/cache.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderRequest } from "@arnilo/prism";
+/** Clamp for `x-grok-conv-id` (session/customer id, never a credential). */
+export declare const XAI_CONV_ID_MAX_LENGTH = 128;
+export declare function xaiCacheEnabled(request: ProviderRequest): boolean;
+/** Sticky conversation id for xAI prefix cache routing. */
+export declare function xGrokConvId(request: ProviderRequest): string | undefined;

package/dist/cache.js

@@ -0,0 +1,19 @@
+import { sanitizeCacheKey } from "@arnilo/prism";
+/** Clamp for `x-grok-conv-id` (session/customer id, never a credential). */
+export const XAI_CONV_ID_MAX_LENGTH = 128;
+export function xaiCacheEnabled(request) {
+    if (request.options?.cacheRetention === "none")
+        return false;
+    if (request.options?.cache?.mode === "off")
+        return false;
+    if (request.model.cache?.kind === "none")
+        return false;
+    return true;
+}
+/** Sticky conversation id for xAI prefix cache routing. */
+export function xGrokConvId(request) {
+    if (!xaiCacheEnabled(request))
+        return undefined;
+    return sanitizeCacheKey(request.options?.cache?.key ?? request.options?.cacheKey ?? request.options?.sessionId, XAI_CONV_ID_MAX_LENGTH);
+}
+//# sourceMappingURL=cache.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { type CredentialValueSource, type ModelConfig, type ProviderPackage } from "@arnilo/prism";
+import { type XaiOAuthOptions } from "./oauth.js";
+export interface XaiProviderPackageOptions {
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    readonly baseUrl?: string;
+    readonly id?: string;
+    readonly models?: readonly ModelConfig[];
+    readonly oauth?: XaiOAuthOptions;
+}
+export declare function createXaiProviderPackage(options?: XaiProviderPackageOptions): ProviderPackage;
+export { XAI_CONV_ID_MAX_LENGTH, xaiCacheEnabled, xGrokConvId } from "./cache.js";
+export { defineXaiModel, type ListXaiModelsOptions, listXaiModels, mapXaiModel, XAI_DEFAULT_BASE_URL, type XaiModelConfig, type XaiModelEntry, xaiModels, } from "./models.js";
+export { createXaiOAuthProvider, parseXaiTokenCredentials, XAI_DEFAULT_CLIENT_ID, XAI_DEFAULT_DEVICE_CODE_URL, XAI_DEFAULT_REFERRER, XAI_DEFAULT_REVOKE_URL, XAI_DEFAULT_SCOPE, XAI_DEFAULT_TOKEN_URL, XAI_REFRESH_SKEW_MS, type XaiOAuthOptions, } from "./oauth.js";
+export { createXaiProvider, toXaiMessage, type XaiProviderOptions, xaiBody, xaiEvents } from "./provider.js";
+export { xaiReplayThinking } from "./thinking.js";

package/dist/index.js

@@ -0,0 +1,29 @@
+import { defineProviderPackage } from "@arnilo/prism";
+import { xaiModels } from "./models.js";
+import { createXaiOAuthProvider } from "./oauth.js";
+import { createXaiProvider } from "./provider.js";
+export function createXaiProviderPackage(options = {}) {
+    const providerId = options.id ?? "xai";
+    return defineProviderPackage({
+        name: "@arnilo/prism-provider-xai",
+        description: "xAI (Grok) provider package for Prism.",
+        docs: { links: ["docs/providers/xai.md"] },
+        setup(api) {
+            api.registerProvider(createXaiProvider(options));
+            for (const model of options.models ?? xaiModels)
+                api.registerModel({ ...model, provider: providerId });
+            api.registerAuthMethod({ kind: "api_key", provider: providerId, credentialName: "apiKey" });
+            api.registerAuthMethod({
+                kind: "oauth",
+                provider: providerId,
+                oauth: createXaiOAuthProvider({ fetch: options.fetch, ...options.oauth }),
+            });
+        },
+    });
+}
+export { XAI_CONV_ID_MAX_LENGTH, xaiCacheEnabled, xGrokConvId } from "./cache.js";
+export { defineXaiModel, listXaiModels, mapXaiModel, XAI_DEFAULT_BASE_URL, xaiModels, } from "./models.js";
+export { createXaiOAuthProvider, parseXaiTokenCredentials, XAI_DEFAULT_CLIENT_ID, XAI_DEFAULT_DEVICE_CODE_URL, XAI_DEFAULT_REFERRER, XAI_DEFAULT_REVOKE_URL, XAI_DEFAULT_SCOPE, XAI_DEFAULT_TOKEN_URL, XAI_REFRESH_SKEW_MS, } from "./oauth.js";
+export { createXaiProvider, toXaiMessage, xaiBody, xaiEvents } from "./provider.js";
+export { xaiReplayThinking } from "./thinking.js";
+//# sourceMappingURL=index.js.map

package/dist/models.d.ts

@@ -0,0 +1,26 @@
+import { type CredentialValueSource, type ModelConfig } from "@arnilo/prism";
+export declare const XAI_DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export interface XaiModelConfig extends Omit<ModelConfig, "provider"> {
+    readonly provider?: "xai";
+}
+export interface ListXaiModelsOptions {
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    readonly baseUrl?: string;
+    readonly signal?: AbortSignal;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly provider?: string;
+}
+export interface XaiModelEntry {
+    readonly id: string;
+    readonly object?: string;
+    readonly created?: number;
+    readonly owned_by?: string;
+}
+export declare function defineXaiModel(config: XaiModelConfig): ModelConfig;
+/** Caller-gated `GET {base}/models`. Never invoked by `createXaiProviderPackage`. */
+export declare function listXaiModels(options?: ListXaiModelsOptions): Promise<ModelConfig[]>;
+export declare function mapXaiModel(entry: XaiModelEntry, options?: {
+    readonly provider?: string;
+}): ModelConfig;
+export declare const xaiModels: ModelConfig[];

package/dist/models.js

@@ -0,0 +1,75 @@
+import { redactSecrets, resolveCredentialValue } from "@arnilo/prism";
+import { readBoundedResponseJson, readBoundedResponseText } from "@arnilo/prism/providers/transport";
+export const XAI_DEFAULT_BASE_URL = "https://api.x.ai/v1";
+const FEATURED = {
+    "grok-4.6": {
+        displayName: "Grok 4.6",
+        limits: { contextWindow: 500_000, maxOutputTokens: 500_000 },
+        cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
+    },
+    "grok-4.3": {
+        displayName: "Grok 4.3",
+        limits: { contextWindow: 1_000_000, maxOutputTokens: 30_000 },
+        cost: { input: 1.25, output: 2.5, cacheRead: 0.2, cacheWrite: 0 },
+    },
+    "grok-build-0.1": {
+        displayName: "Grok Build 0.1",
+        limits: { contextWindow: 256_000, maxOutputTokens: 256_000 },
+        cost: { input: 1, output: 2, cacheRead: 0.2, cacheWrite: 0 },
+    },
+};
+export function defineXaiModel(config) {
+    return {
+        ...config,
+        provider: "xai",
+        capabilities: {
+            input: ["text", "image"],
+            output: ["text"],
+            reasoning: true,
+            tools: true,
+            streaming: true,
+            structuredOutput: "json_schema",
+            ...config.capabilities,
+        },
+        cache: config.cache ?? { kind: "implicit" },
+    };
+}
+/** Caller-gated `GET {base}/models`. Never invoked by `createXaiProviderPackage`. */
+export async function listXaiModels(options = {}) {
+    const provider = options.provider ?? "xai";
+    const baseUrl = (options.baseUrl ?? XAI_DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const token = await resolveCredentialValue(options.apiKey, { provider, name: "apiKey" });
+    const response = await (options.fetch ?? fetch)(`${baseUrl}/models`, {
+        method: "GET",
+        headers: { ...options.headers, ...(token ? { authorization: `Bearer ${token}` } : {}) },
+        signal: options.signal,
+    });
+    if (!response.ok) {
+        const body = await readBoundedResponseText(response, { secrets: [token] });
+        throw new Error(`xAI model discovery failed: ${response.status} ${redactSecrets(body, [token])}`);
+    }
+    const payload = await readBoundedResponseJson(response);
+    if (!Array.isArray(payload.data))
+        throw new Error("xAI model discovery response missing data array");
+    return payload.data.map((entry) => mapXaiModel(entry, { provider }));
+}
+export function mapXaiModel(entry, options = {}) {
+    if (!entry || typeof entry.id !== "string" || entry.id.length === 0) {
+        throw new Error("xAI model entry missing id");
+    }
+    const known = FEATURED[entry.id];
+    return defineXaiModel({
+        provider: options.provider ?? "xai",
+        model: entry.id,
+        displayName: known?.displayName ?? entry.id,
+        limits: known?.limits ?? { contextWindow: 131_072, maxOutputTokens: 8_192 },
+        cost: known?.cost,
+        cache: { kind: "implicit" },
+        compat: { xai: cleanJson({ owned_by: entry.owned_by, created: entry.created }) },
+    });
+}
+export const xaiModels = ["grok-4.6", "grok-4.3", "grok-build-0.1"].map((id) => defineXaiModel({ model: id, ...FEATURED[id] }));
+function cleanJson(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+//# sourceMappingURL=models.js.map

package/dist/oauth.d.ts

@@ -0,0 +1,21 @@
+import type { OAuthCredentials, OAuthProvider, OAuthTokenSuccessPayload } from "@arnilo/prism";
+export declare const XAI_DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+export declare const XAI_DEFAULT_SCOPE = "openid profile email offline_access grok-cli:access api:access";
+export declare const XAI_DEFAULT_DEVICE_CODE_URL = "https://auth.x.ai/oauth2/device/code";
+export declare const XAI_DEFAULT_TOKEN_URL = "https://auth.x.ai/oauth2/token";
+export declare const XAI_DEFAULT_REVOKE_URL = "https://auth.x.ai/oauth2/revoke";
+export declare const XAI_DEFAULT_REFERRER = "prism";
+export declare const XAI_REFRESH_SKEW_MS: number;
+export interface XaiOAuthOptions {
+    readonly clientId?: string;
+    readonly fetch?: typeof fetch;
+    readonly deviceCodeUrl?: string;
+    readonly tokenUrl?: string;
+    readonly revokeUrl?: string;
+    readonly scope?: string;
+    readonly referrer?: string;
+    readonly now?: () => number;
+    readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+export declare function createXaiOAuthProvider(options?: XaiOAuthOptions): OAuthProvider;
+export declare function parseXaiTokenCredentials(json: OAuthTokenSuccessPayload, previousRefresh?: string, now?: () => number): OAuthCredentials;

package/dist/oauth.js

@@ -0,0 +1,98 @@
+import { abortableSleep, pollDeviceCodeToken, redactOAuthError, throwIfAborted } from "@arnilo/prism";
+import { readBoundedResponseJson, readBoundedResponseText } from "@arnilo/prism/providers/transport";
+export const XAI_DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+export const XAI_DEFAULT_SCOPE = "openid profile email offline_access grok-cli:access api:access";
+export const XAI_DEFAULT_DEVICE_CODE_URL = "https://auth.x.ai/oauth2/device/code";
+export const XAI_DEFAULT_TOKEN_URL = "https://auth.x.ai/oauth2/token";
+export const XAI_DEFAULT_REVOKE_URL = "https://auth.x.ai/oauth2/revoke";
+export const XAI_DEFAULT_REFERRER = "prism";
+export const XAI_REFRESH_SKEW_MS = 5 * 60 * 1000;
+const DEFAULT_TOKEN_LIFETIME_SECONDS = 3600;
+export function createXaiOAuthProvider(options = {}) {
+    const clientId = options.clientId ?? XAI_DEFAULT_CLIENT_ID;
+    const fetchImpl = options.fetch ?? fetch;
+    const deviceCodeUrl = options.deviceCodeUrl ?? XAI_DEFAULT_DEVICE_CODE_URL;
+    const tokenUrl = options.tokenUrl ?? XAI_DEFAULT_TOKEN_URL;
+    const revokeUrl = options.revokeUrl ?? XAI_DEFAULT_REVOKE_URL;
+    const scope = options.scope ?? XAI_DEFAULT_SCOPE;
+    const referrer = options.referrer ?? XAI_DEFAULT_REFERRER;
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? abortableSleep;
+    return {
+        id: "xai",
+        async login(callbacks) {
+            throwIfAborted(callbacks?.signal);
+            if (!callbacks?.onDeviceCode) {
+                throw new Error("xAI SuperGrok login requires onDeviceCode");
+            }
+            return pollDeviceCodeToken({
+                fetchImpl,
+                deviceCodeUrl,
+                tokenUrl,
+                clientId,
+                scope,
+                extraDeviceParams: { referrer },
+                bodyEncoding: "form",
+                callbacks,
+                errorPrefix: "xAI",
+                now,
+                sleep,
+                parseTokenCredentials: (json) => parseXaiTokenCredentials(json, undefined, now),
+            });
+        },
+        async refresh(credentials) {
+            if (!credentials.refresh)
+                return credentials;
+            return exchangeForm(fetchImpl, tokenUrl, { grant_type: "refresh_token", client_id: clientId, refresh_token: credentials.refresh }, [credentials.access, credentials.refresh], (json) => parseXaiTokenCredentials(json, credentials.refresh, now));
+        },
+        async revoke(credentials) {
+            const token = credentials.access ?? credentials.refresh;
+            if (!token)
+                return;
+            const secrets = [credentials.access, credentials.refresh];
+            try {
+                const response = await fetchImpl(revokeUrl, {
+                    method: "POST",
+                    headers: { "content-type": "application/x-www-form-urlencoded" },
+                    body: new URLSearchParams({
+                        token,
+                        client_id: clientId,
+                        token_type_hint: credentials.access ? "access_token" : "refresh_token",
+                    }).toString(),
+                });
+                if (!response.ok)
+                    await readBoundedResponseText(response, { secrets });
+            }
+            catch {
+                // best-effort; local store delete is the fail-closed boundary
+            }
+        },
+        getCredential(credentials) {
+            return credentials.access ? { type: "bearer", value: credentials.access } : undefined;
+        },
+    };
+}
+export function parseXaiTokenCredentials(json, previousRefresh, now = Date.now) {
+    const expiresIn = json.expires_in ?? DEFAULT_TOKEN_LIFETIME_SECONDS;
+    return {
+        access: json.access_token,
+        refresh: json.refresh_token ?? previousRefresh,
+        expires: now() + expiresIn * 1_000 - XAI_REFRESH_SKEW_MS,
+    };
+}
+async function exchangeForm(fetchImpl, url, body, secrets, parse) {
+    const response = await fetchImpl(url, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams(body).toString(),
+    });
+    if (!response.ok) {
+        const detail = await readBoundedResponseText(response, { secrets });
+        throw redactOAuthError(new Error(`xAI token request failed: ${response.status} ${detail}`), secrets);
+    }
+    const json = await readBoundedResponseJson(response, {
+        shape: (value) => typeof value === "object" && value !== null && typeof value.access_token === "string",
+    });
+    return parse(json);
+}
+//# sourceMappingURL=oauth.js.map

package/dist/provider.d.ts

@@ -0,0 +1,14 @@
+import type { AIProvider, JsonObject, Message, ProviderEvent, ProviderRequest } from "@arnilo/prism";
+import { type CredentialValueSource } from "@arnilo/prism";
+import { XAI_DEFAULT_BASE_URL } from "./models.js";
+export { XAI_DEFAULT_BASE_URL };
+export interface XaiProviderOptions {
+    readonly id?: string;
+    readonly baseUrl?: string;
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+}
+export declare function createXaiProvider(options?: XaiProviderOptions): AIProvider;
+export declare function xaiBody(request: ProviderRequest): JsonObject;
+export declare function xaiEvents(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<ProviderEvent>;
+export declare function toXaiMessage(message: Message, request: ProviderRequest): JsonObject;

package/dist/provider.js

@@ -0,0 +1,63 @@
+import { applyOpenAIChatStructuredOutput, serializeOpenAIChatMessage } from "@arnilo/prism/providers/openai";
+import { buildOpenAIChatBody, createOpenAICompatibleProvider, openAIChatEvents } from "@arnilo/prism/providers/openai-compatible";
+import { xGrokConvId } from "./cache.js";
+import { XAI_DEFAULT_BASE_URL } from "./models.js";
+import { xaiReplayThinking } from "./thinking.js";
+export { XAI_DEFAULT_BASE_URL };
+export function createXaiProvider(options = {}) {
+    return createOpenAICompatibleProvider({
+        id: options.id ?? "xai",
+        baseUrl: (options.baseUrl ?? XAI_DEFAULT_BASE_URL).replace(/\/+$/, ""),
+        apiKey: options.apiKey,
+        fetch: options.fetch,
+        doneUsage: true,
+        requestFailedPrefix: "xAI request failed",
+        serializeMessage: (message, request) => toXaiMessage(message, request),
+        extraHeaders: (request) => {
+            const convId = xGrokConvId(request);
+            const headers = {};
+            if (convId)
+                headers["x-grok-conv-id"] = convId;
+            return headers;
+        },
+        transformBody: (body, request) => xaiTransform(body, request),
+    });
+}
+export function xaiBody(request) {
+    return buildOpenAIChatBody(request, {
+        serializeMessage: (message, req) => toXaiMessage(message, req),
+        transformBody: (body, req) => xaiTransform(body, req),
+    });
+}
+export function xaiEvents(body, signal) {
+    return openAIChatEvents(body, { signal, doneUsage: true });
+}
+export function toXaiMessage(message, request) {
+    if (!xaiReplayThinking(request)) {
+        return serializeOpenAIChatMessage(message, request.model.capabilities ?? {});
+    }
+    const thinking = message.content.filter((part) => part.type === "thinking").map((part) => part.text);
+    const reasoningContent = thinking.length > 0 ? thinking.join("\n") : undefined;
+    const withoutThinking = {
+        ...message,
+        content: message.content.filter((part) => part.type !== "thinking"),
+    };
+    return clean({
+        ...serializeOpenAIChatMessage(withoutThinking, request.model.capabilities ?? {}),
+        reasoning_content: reasoningContent,
+    });
+}
+function xaiTransform(body, request) {
+    const { maxTokens, ...rest } = body;
+    const transformed = {
+        ...rest,
+        max_tokens: maxTokens ?? request.model.limits?.maxOutputTokens,
+        ...request.options?.extra,
+    };
+    applyOpenAIChatStructuredOutput(transformed, request.options?.structuredOutput);
+    return clean(transformed);
+}
+function clean(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+//# sourceMappingURL=provider.js.map

package/dist/thinking.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderRequest } from "@arnilo/prism";
+/** Reasoning models must replay prior thinking as `reasoning_content` or the prefix cache breaks. */
+export declare function xaiReplayThinking(request: ProviderRequest): boolean;

package/dist/thinking.js

@@ -0,0 +1,5 @@
+/** Reasoning models must replay prior thinking as `reasoning_content` or the prefix cache breaks. */
+export function xaiReplayThinking(request) {
+    return request.model.capabilities?.reasoning === true;
+}
+//# sourceMappingURL=thinking.js.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@arnilo/prism-provider-xai",
+  "version": "0.2.9",
+  "description": "xAI (Grok) provider package for Prism.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/with-build-lock.mjs tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node ../../scripts/with-build-lock.mjs node --test dist/__tests__/*.test.js",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "@arnilo/prism": "0.2.9"
+  },
+  "devDependencies": {
+    "@arnilo/prism": "file:../.."
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ashiqrniloy/prism.git",
+    "directory": "packages/provider-xai"
+  },
+  "bugs": {
+    "url": "https://github.com/ashiqrniloy/prism/issues"
+  },
+  "homepage": "https://github.com/ashiqrniloy/prism/tree/main/packages/provider-xai#readme",
+  "keywords": [
+    "prism",
+    "provider",
+    "xai",
+    "grok",
+    "supergrok",
+    "agent",
+    "llm"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}