@ai-sdk/xai 4.0.21 → 4.0.23

package/docs/01-xai.mdx

@@ -92,10 +92,10 @@ and support structured data generation with [`Output`](/docs/reference/ai-sdk-co
 
 ### Reasoning Effort
 
-For reasoning-capable models you can control how much effort the model spends
-thinking before responding via `providerOptions.xai.reasoningEffort`. This
-works for both the Responses API (default) and the Chat Completions API
-(`xai.chat()`).
+For models with configurable reasoning, you can control how much effort the
+model spends thinking before responding via
+`providerOptions.xai.reasoningEffort`. This works for both the Responses API
+(default) and the Chat Completions API (`xai.chat()`).
 
 ```ts
 import { xai } from '@ai-sdk/xai';
@@ -110,13 +110,12 @@ const { text } = await generateText({
 });
 ```
 
-Supported values:
+The AI SDK option accepts these values, but each xAI model supports a subset:
 
 - `'none'` — Disables reasoning entirely; no thinking tokens are used. Best
-  for simple use cases that need a near-instant response. Supported by
-  `grok-4.3` and newer reasoning models.
-- `'low'` (default) — Uses some reasoning tokens, but still fast. Good for
-  general agentic use and tool calling.
+  for simple use cases that need a near-instant response.
+- `'low'` — Uses some reasoning tokens, but still fast. Good for general
+  agentic use and tool calling.
 - `'medium'` — More thinking for less-latency-sensitive applications such as
   complex data analysis and long-context reasoning.
 - `'high'` — More reasoning tokens for deeper thinking. Suited for very
@@ -124,9 +123,15 @@ Supported values:
   tasks.
 
 <Note>
-  Not every Grok model accepts every value. See xAI's [reasoning
-  docs](https://docs.x.ai/docs/guides/reasoning) for the values supported by
-  your selected model. `'none'` requires `grok-4.3` or newer.
+  Support and defaults are model-specific. `grok-4.3` supports `'none'`,
+  `'low'`, `'medium'`, and `'high'`. `grok-4.5` supports `'low'`, `'medium'`,
+  and `'high'`, defaults to `'high'`, and cannot disable reasoning. The
+  `grok-4.20-reasoning` and `grok-4.20-non-reasoning` variants do not accept
+  this option. For `grok-4.20-multi-agent`, `'low'`, `'medium'`, and `'high'`
+  control the number of agents instead of reasoning depth. See xAI's [reasoning
+  docs](https://docs.x.ai/developers/model-capabilities/text/reasoning) and
+  [Grok 4.3 model page](https://docs.x.ai/developers/models/grok-4.3) for
+  current details.
 </Note>
 
 ## Realtime Models
@@ -499,7 +504,7 @@ import { xai, type XaiLanguageModelResponsesOptions } from '@ai-sdk/xai';
 import { generateText } from 'ai';
 
 const result = await generateText({
-  model: xai.responses('grok-4.20-non-reasoning'),
+  model: xai.responses('grok-4.5'),
   providerOptions: {
     xai: {
       reasoningEffort: 'high',
@@ -513,7 +518,7 @@ The following provider options are available:
 
 - **reasoningEffort** _'none' | 'low' | 'medium' | 'high'_
 
-  Control the reasoning effort for the model. See [Reasoning Effort](#reasoning-effort) for details on each value. `'none'` disables reasoning entirely (requires `grok-4.3` or newer).
+  Control the reasoning effort for supported models. See [Reasoning Effort](#reasoning-effort) for model-specific values and defaults.
 
 - **logprobs** _boolean_
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/xai",
-  "version": "4.0.21",
+  "version": "4.0.23",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -29,16 +29,16 @@
     }
   },
   "dependencies": {
+    "@ai-sdk/openai-compatible": "3.0.18",
     "@ai-sdk/provider": "4.0.4",
-    "@ai-sdk/provider-utils": "5.0.14",
-    "@ai-sdk/openai-compatible": "3.0.16"
+    "@ai-sdk/provider-utils": "5.0.16"
   },
   "devDependencies": {
     "@types/node": "22.19.19",
     "tsup": "^8.5.1",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.0",
+    "@ai-sdk/test-server": "2.0.1",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/xai-video-model.ts

@@ -1,11 +1,11 @@
 import {
   AISDKError,
+  APICallError,
   type Experimental_VideoModelV4,
   type Experimental_VideoModelV4File,
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  cancelResponseBody,
   combineHeaders,
   convertUint8ArrayToBase64,
   createJsonResponseHandler,
@@ -15,6 +15,7 @@ import {
   getTopLevelMediaType,
   parseProviderOptions,
   postJsonToApi,
+  safeParseJSON,
   type FetchFunction,
   type ResponseHandler,
 } from '@ai-sdk/provider-utils';
@@ -549,16 +550,80 @@ const xaiVideoStatusJsonResponseHandler = createJsonResponseHandler(
   xaiVideoStatusResponseSchema,
 );
 
+// Generous bound for a `{status, progress}` payload of ~50 bytes.
+const MAX_PENDING_BODY_BYTES = 1024 * 1024;
+
+const textDecoder = new TextDecoder();
+
+// Bounded replacement for `response.text()`. Throws on overflow without
+// cancelling the body: cancelling a tee branch neither settles nor releases
+// the underlying source while the sibling branch is live.
+async function readPendingBody({
+  response,
+  url,
+  requestBodyValues,
+}: Parameters<ResponseHandler<unknown>>[0]): Promise<string> {
+  if (response.body == null) {
+    return '';
+  }
+
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let totalBytes = 0;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      totalBytes += value.length;
+      if (totalBytes > MAX_PENDING_BODY_BYTES) {
+        throw new APICallError({
+          message: `xAI video status response exceeded ${MAX_PENDING_BODY_BYTES} bytes`,
+          url,
+          requestBodyValues,
+          statusCode: response.status,
+          responseHeaders: extractResponseHeaders(response),
+        });
+      }
+
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const merged = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return textDecoder.decode(merged);
+}
+
 const xaiVideoStatusResponseHandler: ResponseHandler<
   z.infer<typeof xaiVideoStatusResponseSchema>
 > = async options => {
+  // xAI answers 202 while a generation is still running, sometimes with an
+  // empty body. Read it rather than cancelling: `body.cancel()` never settles
+  // on a tee branch, which `Response.clone()` in fetch instrumentation creates.
   if (options.response.status === 202) {
     const responseHeaders = extractResponseHeaders(options.response);
-    await cancelResponseBody(options.response);
+    const text = await readPendingBody(options);
+
+    if (text.trim().length === 0) {
+      return { responseHeaders, value: { status: 'pending' } };
+    }
+
+    const parsed = await safeParseJSON({
+      text,
+      schema: xaiVideoStatusResponseSchema,
+    });
 
     return {
       responseHeaders,
-      value: { status: 'pending' },
+      value: parsed.success ? parsed.value : { status: 'pending' },
     };
   }