@ai-sdk/xai 4.0.59 → 5.0.1

package/dist/index.js

@@ -9,1051 +9,64 @@ import {
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
 
-// src/xai-chat-language-model.ts
-import {
-  APICallError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonResponseHandler,
-  extractResponseHeaders,
-  isCustomReasoning,
-  mapReasoningToProviderEffort,
-  parseProviderOptions as parseProviderOptions2,
-  postJsonToApi,
-  safeParseJSON,
-  serializeModelOptions,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
-
-// src/convert-to-xai-chat-messages.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  convertToBase64,
-  getTopLevelMediaType,
-  parseProviderOptions,
-  resolveFullMediaType,
-  resolveProviderReference
-} from "@ai-sdk/provider-utils";
-
-// src/xai-file-part-options.ts
-import { z } from "zod/v4";
-var xaiFilePartProviderOptions = z.object({
-  /**
-   * Controls the resolution at which the model processes the image.
-   * `low` processes the image at reduced resolution and consumes fewer
-   * input tokens, `high` processes the image at full resolution, and
-   * `auto` lets the API decide. Defaults to full resolution when not set.
-   *
-   * Note: the xAI API silently ignores invalid values, so the value is
-   * validated client-side.
-   *
-   * @see https://docs.x.ai/developers/model-capabilities/images/understanding
-   */
-  imageDetail: z.enum(["low", "high", "auto"]).optional()
-});
-
-// src/convert-to-xai-chat-messages.ts
-async function convertToXaiChatMessages(prompt) {
-  var _a;
-  const messages = [];
-  const warnings = [];
-  for (const { role, content } of prompt) {
-    switch (role) {
-      case "system": {
-        messages.push({ role: "system", content });
-        break;
-      }
-      case "user": {
-        if (content.length === 1 && content[0].type === "text") {
-          messages.push({ role: "user", content: content[0].text });
-          break;
-        }
-        const userContent = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              userContent.push({ type: "text", text: part.text });
-              break;
-            }
-            case "file": {
-              switch (part.data.type) {
-                case "reference": {
-                  userContent.push({
-                    type: "file",
-                    file: {
-                      file_id: resolveProviderReference({
-                        reference: part.data.reference,
-                        provider: "xai"
-                      })
-                    }
-                  });
-                  break;
-                }
-                case "text": {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: "text file parts"
-                  });
-                }
-                case "url":
-                case "data": {
-                  if (getTopLevelMediaType(part.mediaType) === "image") {
-                    const filePartOptions = await parseProviderOptions({
-                      provider: "xai",
-                      providerOptions: part.providerOptions,
-                      schema: xaiFilePartProviderOptions
-                    });
-                    userContent.push({
-                      type: "image_url",
-                      image_url: {
-                        url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
-                        ...(filePartOptions == null ? void 0 : filePartOptions.imageDetail) != null && {
-                          detail: filePartOptions.imageDetail
-                        }
-                      }
-                    });
-                  } else {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: `file part media type ${part.mediaType}`
-                    });
-                  }
-                  break;
-                }
-              }
-              break;
-            }
-          }
-        }
-        messages.push({ role: "user", content: userContent });
-        break;
-      }
-      case "assistant": {
-        let text = "";
-        const toolCalls = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              text += part.text;
-              break;
-            }
-            case "tool-call": {
-              toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.input)
-                }
-              });
-              break;
-            }
-          }
-        }
-        messages.push({
-          role: "assistant",
-          content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-        });
-        break;
-      }
-      case "tool": {
-        for (const toolResponse of content) {
-          if (toolResponse.type === "tool-approval-response") {
-            continue;
-          }
-          const output = toolResponse.output;
-          let contentValue;
-          switch (output.type) {
-            case "text":
-            case "error-text":
-              contentValue = output.value;
-              break;
-            case "execution-denied":
-              contentValue = (_a = output.reason) != null ? _a : "Tool call execution denied.";
-              break;
-            case "content":
-            case "json":
-            case "error-json":
-              contentValue = JSON.stringify(output.value);
-              break;
-          }
-          messages.push({
-            role: "tool",
-            tool_call_id: toolResponse.toolCallId,
-            content: contentValue
-          });
-        }
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return { messages, warnings };
-}
-
-// src/convert-xai-chat-usage.ts
-function convertXaiChatUsage(usage) {
-  var _a, _b, _c, _d;
-  const cacheReadTokens = (_b = (_a = usage.prompt_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0;
-  const reasoningTokens = (_d = (_c = usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
-  const promptTokensIncludesCached = cacheReadTokens <= usage.prompt_tokens;
-  return {
-    inputTokens: {
-      total: promptTokensIncludesCached ? usage.prompt_tokens : usage.prompt_tokens + cacheReadTokens,
-      noCache: promptTokensIncludesCached ? usage.prompt_tokens - cacheReadTokens : usage.prompt_tokens,
-      cacheRead: cacheReadTokens,
-      cacheWrite: void 0
-    },
-    outputTokens: {
-      total: usage.completion_tokens + reasoningTokens,
-      text: usage.completion_tokens,
-      reasoning: reasoningTokens
-    },
-    raw: usage
-  };
-}
-
-// src/get-response-metadata.ts
-import { createLanguageModelResponseMetadata } from "@ai-sdk/provider-utils";
-function getResponseMetadata({
-  id,
-  model,
-  created,
-  created_at
-}) {
-  return createLanguageModelResponseMetadata({
-    id,
-    model,
-    created: created != null ? created : created_at
-  });
-}
-
-// src/map-xai-finish-reason.ts
-function mapXaiFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "other";
-  }
-}
-
-// src/supports-reasoning-effort.ts
-var modelsWithoutReasoningEffort = /^grok-4\.20(-\d{4})?-(non-)?reasoning$/;
-function supportsReasoningEffort(modelId) {
-  return !modelsWithoutReasoningEffort.test(modelId);
-}
-
-// src/xai-chat-language-model-options.ts
-import { z as z2 } from "zod/v4";
-var webSourceSchema = z2.object({
-  type: z2.literal("web"),
-  country: z2.string().length(2).optional(),
-  excludedWebsites: z2.array(z2.string()).max(5).optional(),
-  allowedWebsites: z2.array(z2.string()).max(5).optional(),
-  safeSearch: z2.boolean().optional()
-});
-var xSourceSchema = z2.object({
-  type: z2.literal("x"),
-  excludedXHandles: z2.array(z2.string()).optional(),
-  includedXHandles: z2.array(z2.string()).optional(),
-  postFavoriteCount: z2.number().int().optional(),
-  postViewCount: z2.number().int().optional(),
-  /**
-   * @deprecated use `includedXHandles` instead
-   */
-  xHandles: z2.array(z2.string()).optional()
-});
-var newsSourceSchema = z2.object({
-  type: z2.literal("news"),
-  country: z2.string().length(2).optional(),
-  excludedWebsites: z2.array(z2.string()).max(5).optional(),
-  safeSearch: z2.boolean().optional()
-});
-var rssSourceSchema = z2.object({
-  type: z2.literal("rss"),
-  links: z2.array(z2.string().url()).max(1)
-  // currently only supports one RSS link
-});
-var searchSourceSchema = z2.discriminatedUnion("type", [
-  webSourceSchema,
-  xSourceSchema,
-  newsSourceSchema,
-  rssSourceSchema
-]);
-var xaiLanguageModelChatOptions = z2.object({
-  /**
-   * Constrains how hard a reasoning model thinks before responding.
-   *
-   * - `none`: Disables reasoning entirely (supported by `grok-4.3` and newer
-   *   reasoning models). When set, no thinking tokens are used.
-   * - `low` (default): Uses some reasoning tokens, but still fast.
-   * - `medium`: More thinking for less-latency-sensitive applications.
-   * - `high`: Uses more reasoning tokens for deeper thinking.
-   * - `xhigh`: Uses the most reasoning tokens (supported by `grok-4.6`).
-   *
-   * Note: Not every Grok model accepts every value. Refer to xAI's docs for
-   * the values supported by your selected model.
-   *
-   * @see https://docs.x.ai/docs/guides/reasoning
-   */
-  reasoningEffort: z2.enum(["none", "low", "medium", "high", "xhigh"]).optional(),
-  logprobs: z2.boolean().optional(),
-  topLogprobs: z2.number().int().min(0).max(8).optional(),
-  serviceTier: z2.enum(["default", "priority"]).optional(),
-  /**
-   * Whether to enable parallel function calling during tool use.
-   * When true, the model can call multiple functions in parallel.
-   * When false, the model will call functions sequentially.
-   * Defaults to true.
-   */
-  parallel_function_calling: z2.boolean().optional(),
-  /**
-   * @deprecated xAI has deprecated Live Search (`search_parameters`) in favor
-   * of the Agent Tools API. Requests using this option now return a "Live
-   * search is deprecated" error. Use the `web_search` / `x_search` tools
-   * instead (e.g. `xai.tools.webSearch()`, `xai.tools.xSearch()`) with
-   * `xai.responses(modelId)`.
-   *
-   * @see https://docs.x.ai/docs/guides/tools/overview
-   */
-  searchParameters: z2.object({
-    /**
-     * search mode preference
-     * - "off": disables search completely
-     * - "auto": model decides whether to search (default)
-     * - "on": always enables search
-     */
-    mode: z2.enum(["off", "auto", "on"]),
-    /**
-     * whether to return citations in the response
-     * defaults to true
-     */
-    returnCitations: z2.boolean().optional(),
-    /**
-     * start date for search data (ISO8601 format: YYYY-MM-DD)
-     */
-    fromDate: z2.string().optional(),
-    /**
-     * end date for search data (ISO8601 format: YYYY-MM-DD)
-     */
-    toDate: z2.string().optional(),
-    /**
-     * maximum number of search results to consider
-     * defaults to 20
-     */
-    maxSearchResults: z2.number().min(1).max(50).optional(),
-    /**
-     * data sources to search from.
-     * defaults to [{ type: 'web' }, { type: 'x' }] if not specified.
-     *
-     * @example
-     * sources: [{ type: 'web', country: 'US' }, { type: 'x' }]
-     */
-    sources: z2.array(searchSourceSchema).optional()
-  }).optional()
-});
-
-// src/xai-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
-var chatCompletionsErrorSchema = z3.object({
-  error: z3.object({
-    message: z3.string(),
-    type: z3.string().nullish(),
-    param: z3.any().nullish(),
-    code: z3.union([z3.string(), z3.number()]).nullish()
-  })
-});
-var responsesErrorSchema = z3.object({
-  code: z3.string(),
-  error: z3.string()
-});
-var speechErrorSchema = z3.object({
-  error: z3.string()
-});
-var xaiErrorDataSchema = z3.union([
-  chatCompletionsErrorSchema,
-  responsesErrorSchema,
-  speechErrorSchema
-]);
-var xaiFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: xaiErrorDataSchema,
-  errorToMessage: (data) => {
-    if (typeof data.error === "string") {
-      return "code" in data ? `${data.code}: ${data.error}` : data.error;
-    }
-    return data.error.message;
-  }
-});
-
-// src/xai-prepare-tools.ts
-import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
-} from "@ai-sdk/provider";
-function prepareTools({
-  tools,
-  toolChoice
-}) {
-  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
-  const toolWarnings = [];
-  if (tools == null) {
-    return { tools: void 0, toolChoice: void 0, toolWarnings };
-  }
-  const xaiTools2 = [];
-  for (const tool of tools) {
-    if (tool.type === "provider") {
-      toolWarnings.push({
-        type: "unsupported",
-        feature: `provider-defined tool ${tool.name}`
-      });
-    } else {
-      xaiTools2.push({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema,
-          ...tool.strict != null ? { strict: tool.strict } : {}
-        }
-      });
-    }
-  }
-  if (toolChoice == null) {
-    return { tools: xaiTools2, toolChoice: void 0, toolWarnings };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-    case "none":
-      return { tools: xaiTools2, toolChoice: type, toolWarnings };
-    case "required":
-      return { tools: xaiTools2, toolChoice: "required", toolWarnings };
-    case "tool":
-      return {
-        tools: xaiTools2,
-        toolChoice: {
-          type: "function",
-          function: { name: toolChoice.toolName }
-        },
-        toolWarnings
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError2({
-        functionality: `tool choice type: ${_exhaustiveCheck}`
-      });
-    }
-  }
-}
-
-// src/xai-chat-language-model.ts
-var XaiChatLanguageModel = class _XaiChatLanguageModel {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    this.supportedUrls = {
-      "image/*": [/^https?:\/\/.*$/]
-    };
-    this.modelId = modelId;
-    this.config = config;
-  }
-  static [WORKFLOW_SERIALIZE](model) {
-    return serializeModelOptions({
-      modelId: model.modelId,
-      config: model.config
-    });
-  }
-  static [WORKFLOW_DESERIALIZE](options) {
-    return new _XaiChatLanguageModel(options.modelId, options.config);
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  async getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
-    seed,
-    reasoning,
-    responseFormat,
-    providerOptions,
-    tools,
-    toolChoice
-  }) {
-    var _a, _b, _c;
-    const warnings = [];
-    const options = (_a = await parseProviderOptions2({
-      provider: "xai",
-      providerOptions,
-      schema: xaiLanguageModelChatOptions
-    })) != null ? _a : {};
-    if (topK != null) {
-      warnings.push({ type: "unsupported", feature: "topK" });
-    }
-    if (frequencyPenalty != null) {
-      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
-    }
-    if (presencePenalty != null) {
-      warnings.push({ type: "unsupported", feature: "presencePenalty" });
-    }
-    if (stopSequences != null) {
-      warnings.push({ type: "unsupported", feature: "stopSequences" });
-    }
-    const { messages, warnings: messageWarnings } = await convertToXaiChatMessages(prompt);
-    warnings.push(...messageWarnings);
-    const {
-      tools: xaiTools2,
-      toolChoice: xaiToolChoice,
-      toolWarnings
-    } = prepareTools({
-      tools,
-      toolChoice
-    });
-    warnings.push(...toolWarnings);
-    let reasoningEffort = options.reasoningEffort;
-    if (reasoningEffort == null && isCustomReasoning(reasoning)) {
-      if (!supportsReasoningEffort(this.modelId)) {
-        warnings.push({
-          type: "unsupported",
-          feature: "reasoning",
-          details: `reasoning "${reasoning}" is not supported by this model.`
-        });
-      } else if (reasoning === "none") {
-        reasoningEffort = "none";
-      } else {
-        reasoningEffort = mapReasoningToProviderEffort({
-          reasoning,
-          effortMap: {
-            minimal: "low",
-            low: "low",
-            medium: "medium",
-            high: "high",
-            xhigh: this.modelId === "grok-4.6" ? "xhigh" : "high"
-          },
-          warnings
-        });
-      }
-    }
-    const baseArgs = {
-      // model id
-      model: this.modelId,
-      // standard generation settings
-      logprobs: options.logprobs === true || options.topLogprobs != null ? true : void 0,
-      top_logprobs: options.topLogprobs,
-      max_completion_tokens: maxOutputTokens,
-      temperature,
-      top_p: topP,
-      seed,
-      reasoning_effort: reasoningEffort,
-      // scheduling priority
-      service_tier: options.serviceTier,
-      // parallel function calling
-      parallel_function_calling: options.parallel_function_calling,
-      // response format
-      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
-        type: "json_schema",
-        json_schema: {
-          name: (_b = responseFormat.name) != null ? _b : "response",
-          schema: responseFormat.schema,
-          strict: true
-        }
-      } : { type: "json_object" } : void 0,
-      // search parameters
-      search_parameters: options.searchParameters ? {
-        mode: options.searchParameters.mode,
-        return_citations: options.searchParameters.returnCitations,
-        from_date: options.searchParameters.fromDate,
-        to_date: options.searchParameters.toDate,
-        max_search_results: options.searchParameters.maxSearchResults,
-        sources: (_c = options.searchParameters.sources) == null ? void 0 : _c.map((source) => {
-          var _a2;
-          return {
-            type: source.type,
-            ...source.type === "web" && {
-              country: source.country,
-              excluded_websites: source.excludedWebsites,
-              allowed_websites: source.allowedWebsites,
-              safe_search: source.safeSearch
-            },
-            ...source.type === "x" && {
-              excluded_x_handles: source.excludedXHandles,
-              included_x_handles: (_a2 = source.includedXHandles) != null ? _a2 : source.xHandles,
-              post_favorite_count: source.postFavoriteCount,
-              post_view_count: source.postViewCount
-            },
-            ...source.type === "news" && {
-              country: source.country,
-              excluded_websites: source.excludedWebsites,
-              safe_search: source.safeSearch
-            },
-            ...source.type === "rss" && {
-              links: source.links
-            }
-          };
-        })
-      } : void 0,
-      // messages in xai format
-      messages,
-      // tools in xai format
-      tools: xaiTools2,
-      tool_choice: xaiToolChoice
-    };
-    return {
-      args: baseArgs,
-      warnings
-    };
-  }
-  async doGenerate(options) {
-    var _a, _b, _c, _d;
-    const { args: body, warnings } = await this.getArgs(options);
-    const url = `${(_a = this.config.baseURL) != null ? _a : "https://api.x.ai/v1"}/chat/completions`;
-    const {
-      responseHeaders,
-      value: response,
-      rawValue: rawResponse
-    } = await postJsonToApi({
-      url,
-      headers: combineHeaders((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
-      body,
-      failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        xaiChatResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    if (response.error != null) {
-      throw new APICallError({
-        message: response.error,
-        url,
-        requestBodyValues: body,
-        statusCode: 200,
-        responseHeaders,
-        responseBody: JSON.stringify(rawResponse),
-        isRetryable: response.code === "The service is currently unavailable"
-      });
-    }
-    const choice = response.choices[0];
-    const content = [];
-    if (choice.message.content != null && choice.message.content.length > 0) {
-      let text = choice.message.content;
-      const lastMessage = body.messages[body.messages.length - 1];
-      if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && text === lastMessage.content) {
-        text = "";
-      }
-      if (text.length > 0) {
-        content.push({ type: "text", text });
-      }
-    }
-    if (choice.message.reasoning_content != null && choice.message.reasoning_content.length > 0) {
-      content.push({
-        type: "reasoning",
-        text: choice.message.reasoning_content
-      });
-    }
-    if (choice.message.tool_calls != null) {
-      for (const toolCall of choice.message.tool_calls) {
-        content.push({
-          type: "tool-call",
-          toolCallId: toolCall.id,
-          toolName: toolCall.function.name,
-          input: toolCall.function.arguments
-        });
-      }
-    }
-    if (response.citations != null) {
-      for (const url2 of response.citations) {
-        content.push({
-          type: "source",
-          sourceType: "url",
-          id: this.config.generateId(),
-          url: url2
-        });
-      }
-    }
-    return {
-      content,
-      finishReason: {
-        unified: mapXaiFinishReason(choice.finish_reason),
-        raw: (_d = choice.finish_reason) != null ? _d : void 0
-      },
-      usage: response.usage ? convertXaiChatUsage(response.usage) : {
-        inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
-        outputTokens: { total: 0, text: 0, reasoning: 0 }
-      },
-      ...response.service_tier != null && {
-        providerMetadata: {
-          xai: { serviceTier: response.service_tier }
-        }
-      },
-      request: { body },
-      response: {
-        ...getResponseMetadata(response),
-        headers: responseHeaders,
-        body: rawResponse
-      },
-      warnings
-    };
-  }
-  async doStream(options) {
-    var _a, _b, _c;
-    const { args, warnings } = await this.getArgs(options);
-    const body = {
-      ...args,
-      stream: true,
-      stream_options: {
-        include_usage: true
-      }
-    };
-    const url = `${(_a = this.config.baseURL) != null ? _a : "https://api.x.ai/v1"}/chat/completions`;
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url,
-      headers: combineHeaders((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
-      body,
-      failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: async ({ response: response2 }) => {
-        const responseHeaders2 = extractResponseHeaders(response2);
-        const contentType = response2.headers.get("content-type");
-        if (contentType == null ? void 0 : contentType.includes("application/json")) {
-          const responseBody = await response2.text();
-          const parsedError = await safeParseJSON({
-            text: responseBody,
-            schema: xaiStreamErrorSchema
-          });
-          if (parsedError.success) {
-            throw new APICallError({
-              message: parsedError.value.error,
-              url,
-              requestBodyValues: body,
-              statusCode: 200,
-              responseHeaders: responseHeaders2,
-              responseBody,
-              isRetryable: parsedError.value.code === "The service is currently unavailable"
-            });
-          }
-          throw new APICallError({
-            message: "Invalid JSON response",
-            url,
-            requestBodyValues: body,
-            statusCode: 200,
-            responseHeaders: responseHeaders2,
-            responseBody
-          });
-        }
-        return createEventSourceResponseHandler(xaiChatChunkSchema)({
-          response: response2,
-          url,
-          requestBodyValues: body
-        });
-      },
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    let finishReason = {
-      unified: "other",
-      raw: void 0
-    };
-    let usage = void 0;
-    let serviceTier = void 0;
-    let isFirstChunk = true;
-    const contentBlocks = {};
-    const lastReasoningDeltas = {};
-    let activeReasoningBlockId = void 0;
-    const self = this;
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          start(controller) {
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          transform(chunk, controller) {
-            if (options.includeRawChunks) {
-              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
-            }
-            if (!chunk.success) {
-              controller.enqueue({ type: "error", error: chunk.error });
-              return;
-            }
-            const value = chunk.value;
-            if (isFirstChunk) {
-              controller.enqueue({
-                type: "response-metadata",
-                ...getResponseMetadata(value)
-              });
-              isFirstChunk = false;
-            }
-            if (value.citations != null) {
-              for (const url2 of value.citations) {
-                controller.enqueue({
-                  type: "source",
-                  sourceType: "url",
-                  id: self.config.generateId(),
-                  url: url2
-                });
-              }
-            }
-            if (value.usage != null) {
-              usage = convertXaiChatUsage(value.usage);
-            }
-            if (value.service_tier != null) {
-              serviceTier = value.service_tier;
-            }
-            const choice = value.choices[0];
-            if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = {
-                unified: mapXaiFinishReason(choice.finish_reason),
-                raw: choice.finish_reason
-              };
-            }
-            if ((choice == null ? void 0 : choice.delta) == null) {
-              return;
-            }
-            const delta = choice.delta;
-            const choiceIndex = choice.index;
-            if (delta.content != null && delta.content.length > 0) {
-              const textContent = delta.content;
-              if (activeReasoningBlockId != null && !contentBlocks[activeReasoningBlockId].ended) {
-                controller.enqueue({
-                  type: "reasoning-end",
-                  id: activeReasoningBlockId
-                });
-                contentBlocks[activeReasoningBlockId].ended = true;
-                activeReasoningBlockId = void 0;
-              }
-              const lastMessage = body.messages[body.messages.length - 1];
-              if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant" && textContent === lastMessage.content) {
-                return;
-              }
-              const blockId = `text-${value.id || choiceIndex}`;
-              if (contentBlocks[blockId] == null) {
-                contentBlocks[blockId] = { type: "text", ended: false };
-                controller.enqueue({
-                  type: "text-start",
-                  id: blockId
-                });
-              }
-              controller.enqueue({
-                type: "text-delta",
-                id: blockId,
-                delta: textContent
-              });
-            }
-            if (delta.reasoning_content != null && delta.reasoning_content.length > 0) {
-              const blockId = `reasoning-${value.id || choiceIndex}`;
-              if (lastReasoningDeltas[blockId] === delta.reasoning_content) {
-                return;
-              }
-              lastReasoningDeltas[blockId] = delta.reasoning_content;
-              if (contentBlocks[blockId] == null) {
-                contentBlocks[blockId] = { type: "reasoning", ended: false };
-                activeReasoningBlockId = blockId;
-                controller.enqueue({
-                  type: "reasoning-start",
-                  id: blockId
-                });
-              }
-              controller.enqueue({
-                type: "reasoning-delta",
-                id: blockId,
-                delta: delta.reasoning_content
-              });
-            }
-            if (delta.tool_calls != null && delta.tool_calls.length > 0) {
-              if (activeReasoningBlockId != null && !contentBlocks[activeReasoningBlockId].ended) {
-                controller.enqueue({
-                  type: "reasoning-end",
-                  id: activeReasoningBlockId
-                });
-                contentBlocks[activeReasoningBlockId].ended = true;
-                activeReasoningBlockId = void 0;
-              }
-              for (const toolCall of delta.tool_calls) {
-                const toolCallId = toolCall.id;
-                controller.enqueue({
-                  type: "tool-input-start",
-                  id: toolCallId,
-                  toolName: toolCall.function.name
-                });
-                controller.enqueue({
-                  type: "tool-input-delta",
-                  id: toolCallId,
-                  delta: toolCall.function.arguments
-                });
-                controller.enqueue({
-                  type: "tool-input-end",
-                  id: toolCallId
-                });
-                controller.enqueue({
-                  type: "tool-call",
-                  toolCallId,
-                  toolName: toolCall.function.name,
-                  input: toolCall.function.arguments
-                });
-              }
-            }
-          },
-          flush(controller) {
-            for (const [blockId, block] of Object.entries(contentBlocks)) {
-              if (!block.ended) {
-                controller.enqueue({
-                  type: block.type === "text" ? "text-end" : "reasoning-end",
-                  id: blockId
-                });
-              }
-            }
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage: usage != null ? usage : {
-                inputTokens: {
-                  total: 0,
-                  noCache: 0,
-                  cacheRead: 0,
-                  cacheWrite: 0
-                },
-                outputTokens: { total: 0, text: 0, reasoning: 0 }
-              },
-              ...serviceTier != null && {
-                providerMetadata: { xai: { serviceTier } }
-              }
-            });
-          }
-        })
-      ),
-      request: { body },
-      response: { headers: responseHeaders }
-    };
-  }
-};
-var xaiUsageSchema = z4.object({
-  prompt_tokens: z4.number(),
-  completion_tokens: z4.number(),
-  total_tokens: z4.number(),
-  cost_in_usd_ticks: z4.number().nullish(),
-  prompt_tokens_details: z4.object({
-    text_tokens: z4.number().nullish(),
-    audio_tokens: z4.number().nullish(),
-    image_tokens: z4.number().nullish(),
-    cached_tokens: z4.number().nullish()
-  }).catchall(z4.json()).nullish(),
-  completion_tokens_details: z4.object({
-    reasoning_tokens: z4.number().nullish(),
-    audio_tokens: z4.number().nullish(),
-    accepted_prediction_tokens: z4.number().nullish(),
-    rejected_prediction_tokens: z4.number().nullish()
-  }).catchall(z4.json()).nullish()
-}).catchall(z4.json());
-var xaiChatResponseSchema = z4.object({
-  id: z4.string().nullish(),
-  created: z4.number().nullish(),
-  model: z4.string().nullish(),
-  choices: z4.array(
-    z4.object({
-      message: z4.object({
-        role: z4.enum(["assistant", "tool"]),
-        content: z4.string().nullish(),
-        reasoning_content: z4.string().nullish(),
-        tool_calls: z4.array(
-          z4.object({
-            id: z4.string(),
-            type: z4.literal("function"),
-            function: z4.object({
-              name: z4.string(),
-              arguments: z4.string()
-            })
-          })
-        ).nullish()
-      }),
-      index: z4.number(),
-      finish_reason: z4.string().nullish()
-    })
-  ).nullish(),
-  object: z4.literal("chat.completion").nullish(),
-  usage: xaiUsageSchema.nullish(),
-  citations: z4.array(z4.string().url()).nullish(),
-  service_tier: z4.string().nullish(),
-  code: z4.string().nullish(),
-  error: z4.string().nullish()
-});
-var xaiChatChunkSchema = z4.object({
-  id: z4.string().nullish(),
-  created: z4.number().nullish(),
-  model: z4.string().nullish(),
-  choices: z4.array(
-    z4.object({
-      delta: z4.object({
-        role: z4.enum(["assistant"]).optional(),
-        content: z4.string().nullish(),
-        reasoning_content: z4.string().nullish(),
-        tool_calls: z4.array(
-          z4.object({
-            id: z4.string(),
-            type: z4.literal("function"),
-            function: z4.object({
-              name: z4.string(),
-              arguments: z4.string()
-            })
-          })
-        ).nullish()
-      }),
-      finish_reason: z4.string().nullish(),
-      index: z4.number()
-    })
-  ),
-  usage: xaiUsageSchema.nullish(),
-  citations: z4.array(z4.string().url()).nullish(),
-  service_tier: z4.string().nullish()
-});
-var xaiStreamErrorSchema = z4.object({
-  code: z4.string(),
-  error: z4.string()
-});
-
 // src/xai-image-model.ts
 import {
-  combineHeaders as combineHeaders2,
+  combineHeaders,
   convertImageModelFileToDataUri,
   createBinaryResponseHandler,
-  createJsonResponseHandler as createJsonResponseHandler2,
+  createJsonResponseHandler,
   createStatusCodeErrorResponseHandler,
   getFromApi,
-  parseProviderOptions as parseProviderOptions3,
-  postJsonToApi as postJsonToApi2,
-  serializeModelOptions as serializeModelOptions2,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
 } from "@ai-sdk/provider-utils";
-import { z as z6 } from "zod/v4";
+import { z as z3 } from "zod/v4";
+
+// src/xai-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var apiErrorSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var responsesErrorSchema = z.object({
+  code: z.string(),
+  error: z.string()
+});
+var speechErrorSchema = z.object({
+  error: z.string()
+});
+var xaiErrorDataSchema = z.union([
+  apiErrorSchema,
+  responsesErrorSchema,
+  speechErrorSchema
+]);
+var xaiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: xaiErrorDataSchema,
+  errorToMessage: (data) => {
+    if (typeof data.error === "string") {
+      return "code" in data ? `${data.code}: ${data.error}` : data.error;
+    }
+    return data.error.message;
+  }
+});
 
 // src/xai-image-model-options.ts
-import { z as z5 } from "zod/v4";
-var xaiImageModelOptions = z5.object({
-  aspect_ratio: z5.string().optional(),
-  output_format: z5.string().optional(),
-  sync_mode: z5.boolean().optional(),
-  resolution: z5.enum(["1k", "2k"]).optional(),
-  quality: z5.enum(["low", "medium", "high"]).optional(),
-  user: z5.string().optional()
+import { z as z2 } from "zod/v4";
+var xaiImageModelOptions = z2.object({
+  aspect_ratio: z2.string().optional(),
+  output_format: z2.string().optional(),
+  sync_mode: z2.boolean().optional(),
+  resolution: z2.enum(["1k", "2k"]).optional(),
+  quality: z2.enum(["low", "medium", "high"]).optional(),
+  user: z2.string().optional()
 });
 
 // src/xai-image-model.ts
@@ -1067,13 +80,13 @@ var XaiImageModel = class _XaiImageModel {
   get provider() {
     return this.config.provider;
   }
-  static [WORKFLOW_SERIALIZE2](model) {
-    return serializeModelOptions2({
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
       modelId: model.modelId,
       config: model.config
     });
   }
-  static [WORKFLOW_DESERIALIZE2](options) {
+  static [WORKFLOW_DESERIALIZE](options) {
     return new _XaiImageModel(options.modelId, options.config);
   }
   async doGenerate({
@@ -1109,7 +122,7 @@ var XaiImageModel = class _XaiImageModel {
         feature: "mask"
       });
     }
-    const xaiOptions = await parseProviderOptions3({
+    const xaiOptions = await parseProviderOptions({
       provider: "xai",
       providerOptions,
       schema: xaiImageModelOptions
@@ -1151,12 +164,12 @@ var XaiImageModel = class _XaiImageModel {
     }
     const baseURL = (_a = this.config.baseURL) != null ? _a : "https://api.x.ai/v1";
     const currentDate = (_d = (_c = (_b = this.config._internal) == null ? void 0 : _b.currentDate) == null ? void 0 : _c.call(_b)) != null ? _d : /* @__PURE__ */ new Date();
-    const { value: response, responseHeaders } = await postJsonToApi2({
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: `${baseURL}${endpoint}`,
-      headers: combineHeaders2((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), headers),
+      headers: combineHeaders((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler2(
+      successfulResponseHandler: createJsonResponseHandler(
         xaiImageResponseSchema
       ),
       abortSignal,
@@ -1205,97 +218,154 @@ var XaiImageModel = class _XaiImageModel {
     return value;
   }
 };
-var xaiImageResponseSchema = z6.object({
-  data: z6.array(
-    z6.object({
-      url: z6.string().nullish(),
-      b64_json: z6.string().nullish(),
-      revised_prompt: z6.string().nullish(),
-      respect_moderation: z6.boolean().nullish()
+var xaiImageResponseSchema = z3.object({
+  data: z3.array(
+    z3.object({
+      url: z3.string().nullish(),
+      b64_json: z3.string().nullish(),
+      revised_prompt: z3.string().nullish(),
+      respect_moderation: z3.boolean().nullish()
     })
   ),
-  usage: z6.object({
-    cost_in_usd_ticks: z6.number().nullish()
+  usage: z3.object({
+    cost_in_usd_ticks: z3.number().nullish()
   }).nullish()
 });
 
 // src/xai-batch.ts
 import {
   InvalidArgumentError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError5
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders4,
+  combineHeaders as combineHeaders3,
   convertImageModelFileToDataUri as convertImageModelFileToDataUri2,
   convertBase64ToUint8Array,
   convertAsyncIteratorToReadableStream,
-  createJsonResponseHandler as createJsonResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler3,
   createBinaryResponseHandler as createBinaryResponseHandler2,
   createNullLanguageModelUsage,
   getFromApi as getFromApi2,
   lazySchema as lazySchema7,
   normalizeBatchRequestCounts,
-  parseProviderOptions as parseProviderOptions6,
+  parseProviderOptions as parseProviderOptions4,
   postFormDataToApi,
-  postJsonToApi as postJsonToApi4,
+  postJsonToApi as postJsonToApi3,
   safeValidateTypes,
   zodSchema as zodSchema7
 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
+import { z as z13 } from "zod/v4";
+
+// src/get-response-metadata.ts
+import { createLanguageModelResponseMetadata } from "@ai-sdk/provider-utils";
+function getResponseMetadata({
+  id,
+  model,
+  created,
+  created_at
+}) {
+  return createLanguageModelResponseMetadata({
+    id,
+    model,
+    created: created != null ? created : created_at
+  });
+}
+
+// src/map-xai-finish-reason.ts
+function mapXaiFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "other";
+  }
+}
 
 // src/files/xai-files-api.ts
 import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 var xaiFilesResponseSchema = lazySchema(
   () => zodSchema(
-    z7.object({
-      id: z7.string(),
-      object: z7.string().nullish(),
-      bytes: z7.number().nullish(),
-      created_at: z7.number().nullish(),
-      expires_at: z7.number().nullish(),
-      filename: z7.string().nullish(),
-      purpose: z7.string().nullish(),
-      status: z7.string().nullish()
+    z4.object({
+      id: z4.string(),
+      object: z4.string().nullish(),
+      bytes: z4.number().nullish(),
+      created_at: z4.number().nullish(),
+      expires_at: z4.number().nullish(),
+      filename: z4.string().nullish(),
+      purpose: z4.string().nullish(),
+      status: z4.string().nullish()
     })
   )
 );
 var xaiFileDeleteResponseSchema = lazySchema(
   () => zodSchema(
-    z7.object({
-      id: z7.string(),
-      object: z7.string().nullish(),
-      deleted: z7.boolean()
+    z4.object({
+      id: z4.string(),
+      object: z4.string().nullish(),
+      deleted: z4.boolean()
     })
   )
 );
 
 // src/responses/xai-responses-language-model.ts
 import {
-  combineHeaders as combineHeaders3,
-  createEventSourceResponseHandler as createEventSourceResponseHandler2,
-  createJsonResponseHandler as createJsonResponseHandler3,
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler as createJsonResponseHandler2,
   createProviderStreamError,
-  isCustomReasoning as isCustomReasoning2,
-  mapReasoningToProviderEffort as mapReasoningToProviderEffort2,
-  parseProviderOptions as parseProviderOptions5,
-  postJsonToApi as postJsonToApi3,
-  serializeModelOptions as serializeModelOptions3,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3
+  isCustomReasoning,
+  mapReasoningToProviderEffort,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
 } from "@ai-sdk/provider-utils";
 
+// src/supports-reasoning-effort.ts
+var modelsWithoutReasoningEffort = /^grok-4\.20(-\d{4})?-(non-)?reasoning$/;
+function supportsReasoningEffort(modelId) {
+  return !modelsWithoutReasoningEffort.test(modelId);
+}
+
 // src/responses/convert-to-xai-responses-input.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+  UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 import {
-  convertToBase64 as convertToBase642,
-  getTopLevelMediaType as getTopLevelMediaType2,
-  parseProviderOptions as parseProviderOptions4,
-  resolveFullMediaType as resolveFullMediaType2,
-  resolveProviderReference as resolveProviderReference2
+  convertToBase64,
+  getTopLevelMediaType,
+  parseProviderOptions as parseProviderOptions2,
+  resolveFullMediaType,
+  resolveProviderReference
 } from "@ai-sdk/provider-utils";
+
+// src/xai-file-part-options.ts
+import { z as z5 } from "zod/v4";
+var xaiFilePartProviderOptions = z5.object({
+  /**
+   * Controls the resolution at which the model processes the image.
+   * `low` processes the image at reduced resolution and consumes fewer
+   * input tokens, `high` processes the image at full resolution, and
+   * `auto` lets the API decide. Defaults to full resolution when not set.
+   *
+   * Note: the xAI API silently ignores invalid values, so the value is
+   * validated client-side.
+   *
+   * @see https://docs.x.ai/developers/model-capabilities/images/understanding
+   */
+  imageDetail: z5.enum(["low", "high", "auto"]).optional()
+});
+
+// src/responses/convert-to-xai-responses-input.ts
 async function convertToXaiResponsesInput({
   prompt
 }) {
@@ -1324,7 +394,7 @@ async function convertToXaiResponsesInput({
                 case "reference": {
                   contentParts.push({
                     type: "input_file",
-                    file_id: resolveProviderReference2({
+                    file_id: resolveProviderReference({
                       reference: block.data.reference,
                       provider: "xai"
                     })
@@ -1332,15 +402,15 @@ async function convertToXaiResponsesInput({
                   break;
                 }
                 case "text": {
-                  throw new UnsupportedFunctionalityError3({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "text file parts"
                   });
                 }
                 case "url":
                 case "data": {
-                  if (getTopLevelMediaType2(block.mediaType) === "image") {
-                    const imageUrl = block.data.type === "url" ? block.data.url.toString() : `data:${resolveFullMediaType2({ part: block })};base64,${convertToBase642(block.data.data)}`;
-                    const filePartOptions = await parseProviderOptions4({
+                  if (getTopLevelMediaType(block.mediaType) === "image") {
+                    const imageUrl = block.data.type === "url" ? block.data.url.toString() : `data:${resolveFullMediaType({ part: block })};base64,${convertToBase64(block.data.data)}`;
+                    const filePartOptions = await parseProviderOptions2({
                       provider: "xai",
                       providerOptions: block.providerOptions,
                       schema: xaiFilePartProviderOptions
@@ -1358,7 +428,7 @@ async function convertToXaiResponsesInput({
                       file_url: block.data.url.toString()
                     });
                   } else {
-                    throw new UnsupportedFunctionalityError3({
+                    throw new UnsupportedFunctionalityError({
                       functionality: `file part media type ${block.mediaType} as inline data (xAI Responses requires a URL or a Files API reference for non-image files)`
                     });
                   }
@@ -1491,10 +561,10 @@ async function convertToXaiResponsesInput({
                     break;
                   }
                   case "file": {
-                    if (getTopLevelMediaType2(item.mediaType) === "image" && (item.data.type === "data" || item.data.type === "url")) {
+                    if (getTopLevelMediaType(item.mediaType) === "image" && (item.data.type === "data" || item.data.type === "url")) {
                       outputValue.push({
                         type: "input_image",
-                        image_url: item.data.type === "url" ? item.data.url.toString() : `data:${resolveFullMediaType2({ part: item })};base64,${convertToBase642(item.data.data)}`
+                        image_url: item.data.type === "url" ? item.data.url.toString() : `data:${resolveFullMediaType({ part: item })};base64,${convertToBase64(item.data.data)}`
                       });
                     }
                     break;
@@ -1575,484 +645,484 @@ function mapXaiResponsesFinishReason(finishReason) {
 }
 
 // src/responses/xai-responses-api.ts
-import { z as z8 } from "zod/v4";
-var annotationSchema = z8.union([
-  z8.object({
-    type: z8.literal("url_citation"),
-    url: z8.string(),
-    title: z8.string().optional()
+import { z as z6 } from "zod/v4";
+var annotationSchema = z6.union([
+  z6.object({
+    type: z6.literal("url_citation"),
+    url: z6.string(),
+    title: z6.string().optional()
   }),
-  z8.object({
-    type: z8.string()
+  z6.object({
+    type: z6.string()
   })
 ]);
-var messageContentPartSchema = z8.object({
-  type: z8.string(),
-  text: z8.string().optional(),
-  logprobs: z8.array(z8.any()).optional(),
-  annotations: z8.array(annotationSchema).optional()
+var messageContentPartSchema = z6.object({
+  type: z6.string(),
+  text: z6.string().optional(),
+  logprobs: z6.array(z6.any()).optional(),
+  annotations: z6.array(annotationSchema).optional()
 });
-var reasoningSummaryPartSchema = z8.object({
-  type: z8.string(),
-  text: z8.string()
+var reasoningSummaryPartSchema = z6.object({
+  type: z6.string(),
+  text: z6.string()
 });
-var toolCallSchema = z8.object({
-  name: z8.string().optional(),
-  arguments: z8.string().optional(),
-  input: z8.string().optional(),
-  call_id: z8.string().optional(),
-  id: z8.string(),
-  status: z8.string(),
-  action: z8.any().optional()
+var toolCallSchema = z6.object({
+  name: z6.string().optional(),
+  arguments: z6.string().optional(),
+  input: z6.string().optional(),
+  call_id: z6.string().optional(),
+  id: z6.string(),
+  status: z6.string(),
+  action: z6.any().optional()
 });
-var webSearchWireSourceSchema = z8.object({
-  type: z8.literal("url"),
-  url: z8.string()
+var webSearchWireSourceSchema = z6.object({
+  type: z6.literal("url"),
+  url: z6.string()
 });
-var webSearchWireActionSchema = z8.discriminatedUnion("type", [
-  z8.object({
-    type: z8.literal("search"),
-    query: z8.string().nullish(),
-    queries: z8.array(z8.string()).nullish(),
-    sources: z8.array(z8.unknown()).nullish()
+var webSearchWireActionSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("search"),
+    query: z6.string().nullish(),
+    queries: z6.array(z6.string()).nullish(),
+    sources: z6.array(z6.unknown()).nullish()
   }),
-  z8.object({
-    type: z8.literal("open_page"),
-    url: z8.string().nullish(),
-    sources: z8.array(z8.unknown()).nullish()
+  z6.object({
+    type: z6.literal("open_page"),
+    url: z6.string().nullish(),
+    sources: z6.array(z6.unknown()).nullish()
   }),
-  z8.object({
-    type: z8.literal("find_in_page"),
-    url: z8.string().nullish(),
-    pattern: z8.string().nullish(),
-    sources: z8.array(z8.unknown()).nullish()
+  z6.object({
+    type: z6.literal("find_in_page"),
+    url: z6.string().nullish(),
+    pattern: z6.string().nullish(),
+    sources: z6.array(z6.unknown()).nullish()
   })
 ]);
-var mcpCallSchema = z8.object({
-  name: z8.string().optional(),
-  arguments: z8.string().optional(),
-  output: z8.string().optional(),
-  error: z8.string().optional(),
-  id: z8.string(),
-  status: z8.string(),
-  server_label: z8.string().optional()
+var mcpCallSchema = z6.object({
+  name: z6.string().optional(),
+  arguments: z6.string().optional(),
+  output: z6.string().optional(),
+  error: z6.string().optional(),
+  id: z6.string(),
+  status: z6.string(),
+  server_label: z6.string().optional()
 });
-var outputItemSchema = z8.discriminatedUnion("type", [
-  z8.object({
-    type: z8.literal("web_search_call"),
+var outputItemSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("web_search_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("x_search_call"),
+  z6.object({
+    type: z6.literal("x_search_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("code_interpreter_call"),
+  z6.object({
+    type: z6.literal("code_interpreter_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("code_execution_call"),
+  z6.object({
+    type: z6.literal("code_execution_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("view_image_call"),
+  z6.object({
+    type: z6.literal("view_image_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("view_x_video_call"),
+  z6.object({
+    type: z6.literal("view_x_video_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("file_search_call"),
-    id: z8.string(),
-    status: z8.string(),
-    queries: z8.array(z8.string()).optional(),
-    results: z8.array(
-      z8.object({
-        file_id: z8.string(),
-        filename: z8.string(),
-        score: z8.number(),
-        text: z8.string()
+  z6.object({
+    type: z6.literal("file_search_call"),
+    id: z6.string(),
+    status: z6.string(),
+    queries: z6.array(z6.string()).optional(),
+    results: z6.array(
+      z6.object({
+        file_id: z6.string(),
+        filename: z6.string(),
+        score: z6.number(),
+        text: z6.string()
       })
     ).nullish()
   }),
-  z8.object({
-    type: z8.literal("image_generation_call"),
-    id: z8.string(),
-    status: z8.string(),
-    prompt: z8.string().nullish(),
-    result: z8.string().nullish()
+  z6.object({
+    type: z6.literal("image_generation_call"),
+    id: z6.string(),
+    status: z6.string(),
+    prompt: z6.string().nullish(),
+    result: z6.string().nullish()
   }),
-  z8.object({
-    type: z8.literal("custom_tool_call"),
+  z6.object({
+    type: z6.literal("custom_tool_call"),
     ...toolCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("mcp_call"),
+  z6.object({
+    type: z6.literal("mcp_call"),
     ...mcpCallSchema.shape
   }),
-  z8.object({
-    type: z8.literal("message"),
-    role: z8.string(),
-    content: z8.array(messageContentPartSchema),
-    id: z8.string(),
-    status: z8.string()
+  z6.object({
+    type: z6.literal("message"),
+    role: z6.string(),
+    content: z6.array(messageContentPartSchema),
+    id: z6.string(),
+    status: z6.string()
   }),
-  z8.object({
-    type: z8.literal("function_call"),
-    name: z8.string(),
-    arguments: z8.string(),
-    call_id: z8.string(),
-    id: z8.string()
+  z6.object({
+    type: z6.literal("function_call"),
+    name: z6.string(),
+    arguments: z6.string(),
+    call_id: z6.string(),
+    id: z6.string()
   }),
-  z8.object({
-    type: z8.literal("reasoning"),
-    id: z8.string(),
-    summary: z8.array(reasoningSummaryPartSchema),
-    content: z8.array(z8.object({ type: z8.string(), text: z8.string() })).nullish(),
-    status: z8.string(),
-    encrypted_content: z8.string().nullish()
+  z6.object({
+    type: z6.literal("reasoning"),
+    id: z6.string(),
+    summary: z6.array(reasoningSummaryPartSchema),
+    content: z6.array(z6.object({ type: z6.string(), text: z6.string() })).nullish(),
+    status: z6.string(),
+    encrypted_content: z6.string().nullish()
   })
 ]);
-var xaiResponsesUsageSchema = z8.object({
-  input_tokens: z8.number(),
-  output_tokens: z8.number(),
-  total_tokens: z8.number().optional(),
-  input_tokens_details: z8.object({
-    cached_tokens: z8.number().optional()
-  }).catchall(z8.json()).optional(),
-  output_tokens_details: z8.object({
-    reasoning_tokens: z8.number().optional()
-  }).catchall(z8.json()).optional(),
-  num_sources_used: z8.number().optional(),
-  num_server_side_tools_used: z8.number().optional(),
-  cost_in_usd_ticks: z8.number().nullish()
-}).catchall(z8.json());
-var xaiResponsesResponseSchema = z8.object({
-  id: z8.string().nullish(),
-  created_at: z8.number().nullish(),
-  model: z8.string().nullish(),
-  object: z8.literal("response"),
-  output: z8.array(outputItemSchema),
+var xaiResponsesUsageSchema = z6.object({
+  input_tokens: z6.number(),
+  output_tokens: z6.number(),
+  total_tokens: z6.number().optional(),
+  input_tokens_details: z6.object({
+    cached_tokens: z6.number().optional()
+  }).catchall(z6.json()).optional(),
+  output_tokens_details: z6.object({
+    reasoning_tokens: z6.number().optional()
+  }).catchall(z6.json()).optional(),
+  num_sources_used: z6.number().optional(),
+  num_server_side_tools_used: z6.number().optional(),
+  cost_in_usd_ticks: z6.number().nullish()
+}).catchall(z6.json());
+var xaiResponsesResponseSchema = z6.object({
+  id: z6.string().nullish(),
+  created_at: z6.number().nullish(),
+  model: z6.string().nullish(),
+  object: z6.literal("response"),
+  output: z6.array(outputItemSchema),
   usage: xaiResponsesUsageSchema.nullish(),
-  status: z8.string(),
-  service_tier: z8.string().nullish()
+  status: z6.string(),
+  service_tier: z6.string().nullish()
 });
-var xaiResponsesChunkSchema = z8.union([
-  z8.object({
-    type: z8.literal("response.created"),
+var xaiResponsesChunkSchema = z6.union([
+  z6.object({
+    type: z6.literal("response.created"),
     response: xaiResponsesResponseSchema.partial({ usage: true, status: true })
   }),
-  z8.object({
-    type: z8.literal("response.in_progress"),
+  z6.object({
+    type: z6.literal("response.in_progress"),
     response: xaiResponsesResponseSchema.partial({ usage: true, status: true })
   }),
-  z8.object({
-    type: z8.literal("response.output_item.added"),
+  z6.object({
+    type: z6.literal("response.output_item.added"),
     item: outputItemSchema,
-    output_index: z8.number()
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.output_item.done"),
+  z6.object({
+    type: z6.literal("response.output_item.done"),
     item: outputItemSchema,
-    output_index: z8.number()
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.content_part.added"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
+  z6.object({
+    type: z6.literal("response.content_part.added"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
     part: messageContentPartSchema
   }),
-  z8.object({
-    type: z8.literal("response.content_part.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
+  z6.object({
+    type: z6.literal("response.content_part.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
     part: messageContentPartSchema
   }),
-  z8.object({
-    type: z8.literal("response.output_text.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
-    delta: z8.string(),
-    logprobs: z8.array(z8.any()).optional()
+  z6.object({
+    type: z6.literal("response.output_text.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
+    delta: z6.string(),
+    logprobs: z6.array(z6.any()).optional()
   }),
-  z8.object({
-    type: z8.literal("response.output_text.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
-    text: z8.string(),
-    logprobs: z8.array(z8.any()).optional(),
-    annotations: z8.array(annotationSchema).optional()
+  z6.object({
+    type: z6.literal("response.output_text.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
+    text: z6.string(),
+    logprobs: z6.array(z6.any()).optional(),
+    annotations: z6.array(annotationSchema).optional()
   }),
-  z8.object({
-    type: z8.literal("response.output_text.annotation.added"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
-    annotation_index: z8.number(),
+  z6.object({
+    type: z6.literal("response.output_text.annotation.added"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
+    annotation_index: z6.number(),
     annotation: annotationSchema
   }),
-  z8.object({
-    type: z8.literal("response.reasoning_summary_part.added"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    summary_index: z8.number(),
+  z6.object({
+    type: z6.literal("response.reasoning_summary_part.added"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    summary_index: z6.number(),
     part: reasoningSummaryPartSchema
   }),
-  z8.object({
-    type: z8.literal("response.reasoning_summary_part.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    summary_index: z8.number(),
+  z6.object({
+    type: z6.literal("response.reasoning_summary_part.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    summary_index: z6.number(),
     part: reasoningSummaryPartSchema
   }),
-  z8.object({
-    type: z8.literal("response.reasoning_summary_text.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    summary_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.reasoning_summary_text.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    summary_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.reasoning_summary_text.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    summary_index: z8.number(),
-    text: z8.string()
+  z6.object({
+    type: z6.literal("response.reasoning_summary_text.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    summary_index: z6.number(),
+    text: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.reasoning_text.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.reasoning_text.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.reasoning_text.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    content_index: z8.number(),
-    text: z8.string()
+  z6.object({
+    type: z6.literal("response.reasoning_text.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    content_index: z6.number(),
+    text: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.web_search_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.web_search_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.web_search_call.searching"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.web_search_call.searching"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.web_search_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.web_search_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.x_search_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.x_search_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.x_search_call.searching"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.x_search_call.searching"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.x_search_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.x_search_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.file_search_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.file_search_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.file_search_call.searching"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.file_search_call.searching"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.file_search_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.file_search_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.image_generation_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.image_generation_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.image_generation_call.generating"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.image_generation_call.generating"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.image_generation_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.image_generation_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_execution_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_execution_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_execution_call.executing"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_execution_call.executing"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_execution_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_execution_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_interpreter_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_interpreter_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_interpreter_call.executing"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_interpreter_call.executing"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_interpreter_call.interpreting"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_interpreter_call.interpreting"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.code_interpreter_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.code_interpreter_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
   // Code interpreter code streaming events
-  z8.object({
-    type: z8.literal("response.code_interpreter_call_code.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.code_interpreter_call_code.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.code_interpreter_call_code.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    code: z8.string()
+  z6.object({
+    type: z6.literal("response.code_interpreter_call_code.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    code: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.custom_tool_call_input.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.custom_tool_call_input.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.custom_tool_call_input.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    input: z8.string()
+  z6.object({
+    type: z6.literal("response.custom_tool_call_input.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    input: z6.string()
   }),
   // Function call arguments streaming events (standard function tools)
-  z8.object({
-    type: z8.literal("response.function_call_arguments.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.function_call_arguments.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.function_call_arguments.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    arguments: z8.string()
+  z6.object({
+    type: z6.literal("response.function_call_arguments.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    arguments: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call.in_progress"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.mcp_call.in_progress"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call.executing"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.mcp_call.executing"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call.completed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.mcp_call.completed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call.failed"),
-    item_id: z8.string(),
-    output_index: z8.number()
+  z6.object({
+    type: z6.literal("response.mcp_call.failed"),
+    item_id: z6.string(),
+    output_index: z6.number()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call_arguments.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.mcp_call_arguments.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call_arguments.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    arguments: z8.string().optional()
+  z6.object({
+    type: z6.literal("response.mcp_call_arguments.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    arguments: z6.string().optional()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call_output.delta"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    delta: z8.string()
+  z6.object({
+    type: z6.literal("response.mcp_call_output.delta"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    delta: z6.string()
   }),
-  z8.object({
-    type: z8.literal("response.mcp_call_output.done"),
-    item_id: z8.string(),
-    output_index: z8.number(),
-    output: z8.string().optional()
+  z6.object({
+    type: z6.literal("response.mcp_call_output.done"),
+    item_id: z6.string(),
+    output_index: z6.number(),
+    output: z6.string().optional()
   }),
-  z8.object({
-    type: z8.literal("response.incomplete"),
-    response: z8.object({
-      incomplete_details: z8.object({ reason: z8.string() }).nullish(),
+  z6.object({
+    type: z6.literal("response.incomplete"),
+    response: z6.object({
+      incomplete_details: z6.object({ reason: z6.string() }).nullish(),
       usage: xaiResponsesUsageSchema.nullish(),
-      service_tier: z8.string().nullish()
+      service_tier: z6.string().nullish()
     })
   }),
-  z8.object({
-    type: z8.literal("response.failed"),
-    response: z8.object({
-      error: z8.object({
-        code: z8.string().nullish(),
-        message: z8.string()
+  z6.object({
+    type: z6.literal("response.failed"),
+    response: z6.object({
+      error: z6.object({
+        code: z6.string().nullish(),
+        message: z6.string()
       }).nullish(),
-      incomplete_details: z8.object({ reason: z8.string() }).nullish(),
+      incomplete_details: z6.object({ reason: z6.string() }).nullish(),
       usage: xaiResponsesUsageSchema.nullish()
     })
   }),
-  z8.object({
-    type: z8.literal("error"),
-    code: z8.string().nullish(),
-    message: z8.string(),
-    param: z8.string().nullish()
+  z6.object({
+    type: z6.literal("error"),
+    code: z6.string().nullish(),
+    message: z6.string(),
+    param: z6.string().nullish()
   }),
-  z8.object({
-    type: z8.literal("response.done"),
+  z6.object({
+    type: z6.literal("response.done"),
     response: xaiResponsesResponseSchema
   }),
-  z8.object({
-    type: z8.literal("response.completed"),
+  z6.object({
+    type: z6.literal("response.completed"),
     response: xaiResponsesResponseSchema
   })
 ]);
 
 // src/responses/xai-responses-language-model-options.ts
-import { z as z9 } from "zod/v4";
-var xaiLanguageModelResponsesOptions = z9.object({
+import { z as z7 } from "zod/v4";
+var xaiLanguageModelResponsesOptions = z7.object({
   /**
    * Constrains how hard a reasoning model thinks before responding.
    * Possible values are `none` (disables reasoning entirely; supported by
@@ -2062,32 +1132,32 @@ var xaiLanguageModelResponsesOptions = z9.object({
    *
    * @see https://docs.x.ai/docs/guides/reasoning
    */
-  reasoningEffort: z9.enum(["none", "low", "medium", "high", "xhigh"]).optional(),
-  reasoningSummary: z9.enum(["auto", "concise", "detailed"]).optional(),
-  logprobs: z9.boolean().optional(),
-  topLogprobs: z9.number().int().min(0).max(8).optional(),
-  serviceTier: z9.enum(["default", "priority"]).optional(),
+  reasoningEffort: z7.enum(["none", "low", "medium", "high", "xhigh"]).optional(),
+  reasoningSummary: z7.enum(["auto", "concise", "detailed"]).optional(),
+  logprobs: z7.boolean().optional(),
+  topLogprobs: z7.number().int().min(0).max(8).optional(),
+  serviceTier: z7.enum(["default", "priority"]).optional(),
   /**
    * Whether to store the input message(s) and model response for later retrieval.
    * Must be set to `false` for teams with Zero Data Retention (ZDR) enabled,
    * otherwise the API will return an error.
    * @default true
    */
-  store: z9.boolean().optional(),
+  store: z7.boolean().optional(),
   /**
    * The ID of the previous response from the model.
    */
-  previousResponseId: z9.string().optional(),
+  previousResponseId: z7.string().optional(),
   /**
    * Specify additional output data to include in the model response.
    * Example values: 'file_search_call.results'.
    */
-  include: z9.array(z9.enum(["file_search_call.results"])).nullish()
+  include: z7.array(z7.enum(["file_search_call.results"])).nullish()
 });
 
 // src/responses/xai-responses-prepare-tools.ts
 import {
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError4
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 import { validateTypes } from "@ai-sdk/provider-utils";
 
@@ -2097,25 +1167,25 @@ import {
   lazySchema as lazySchema2,
   zodSchema as zodSchema2
 } from "@ai-sdk/provider-utils";
-import { z as z10 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 var fileSearchArgsSchema = lazySchema2(
   () => zodSchema2(
-    z10.object({
-      vectorStoreIds: z10.array(z10.string()),
-      maxNumResults: z10.number().optional()
+    z8.object({
+      vectorStoreIds: z8.array(z8.string()),
+      maxNumResults: z8.number().optional()
     })
   )
 );
 var fileSearchOutputSchema = lazySchema2(
   () => zodSchema2(
-    z10.object({
-      queries: z10.array(z10.string()),
-      results: z10.array(
-        z10.object({
-          fileId: z10.string(),
-          filename: z10.string(),
-          score: z10.number().min(0).max(1),
-          text: z10.string()
+    z8.object({
+      queries: z8.array(z8.string()),
+      results: z8.array(
+        z8.object({
+          fileId: z8.string(),
+          filename: z8.string(),
+          score: z8.number().min(0).max(1),
+          text: z8.string()
         })
       ).nullable()
     })
@@ -2123,7 +1193,7 @@ var fileSearchOutputSchema = lazySchema2(
 );
 var fileSearchToolFactory = createProviderExecutedToolFactory({
   id: "xai.file_search",
-  inputSchema: lazySchema2(() => zodSchema2(z10.object({}))),
+  inputSchema: lazySchema2(() => zodSchema2(z8.object({}))),
   outputSchema: fileSearchOutputSchema
 });
 var fileSearch = (args) => fileSearchToolFactory(args);
@@ -2134,20 +1204,20 @@ import {
   lazySchema as lazySchema3,
   zodSchema as zodSchema3
 } from "@ai-sdk/provider-utils";
-import { z as z11 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 var imageGenerationArgsSchema = lazySchema3(
   () => zodSchema3(
-    z11.object({
-      action: z11.enum(["auto", "generate", "edit"]).optional()
+    z9.object({
+      action: z9.enum(["auto", "generate", "edit"]).optional()
     })
   )
 );
-var imageGenerationInputSchema = lazySchema3(() => zodSchema3(z11.object({})));
+var imageGenerationInputSchema = lazySchema3(() => zodSchema3(z9.object({})));
 var imageGenerationOutputSchema = lazySchema3(
   () => zodSchema3(
-    z11.object({
-      result: z11.string(),
-      prompt: z11.string().optional()
+    z9.object({
+      result: z9.string(),
+      prompt: z9.string().optional()
     })
   )
 );
@@ -2164,31 +1234,31 @@ import {
   lazySchema as lazySchema4,
   zodSchema as zodSchema4
 } from "@ai-sdk/provider-utils";
-import { z as z12 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 var mcpServerArgsSchema = lazySchema4(
   () => zodSchema4(
-    z12.object({
-      serverUrl: z12.string().describe("The URL of the MCP server"),
-      serverLabel: z12.string().optional().describe("A label for the MCP server"),
-      serverDescription: z12.string().optional().describe("Description of the MCP server"),
-      allowedTools: z12.array(z12.string()).optional().describe("List of allowed tool names"),
-      headers: z12.record(z12.string(), z12.string()).optional().describe("Custom headers to send"),
-      authorization: z12.string().optional().describe("Authorization header value")
+    z10.object({
+      serverUrl: z10.string().describe("The URL of the MCP server"),
+      serverLabel: z10.string().optional().describe("A label for the MCP server"),
+      serverDescription: z10.string().optional().describe("Description of the MCP server"),
+      allowedTools: z10.array(z10.string()).optional().describe("List of allowed tool names"),
+      headers: z10.record(z10.string(), z10.string()).optional().describe("Custom headers to send"),
+      authorization: z10.string().optional().describe("Authorization header value")
     })
   )
 );
 var mcpServerOutputSchema = lazySchema4(
   () => zodSchema4(
-    z12.object({
-      name: z12.string(),
-      arguments: z12.string(),
-      result: z12.unknown()
+    z10.object({
+      name: z10.string(),
+      arguments: z10.string(),
+      result: z10.unknown()
     })
   )
 );
 var mcpServerToolFactory = createProviderExecutedToolFactory3({
   id: "xai.mcp",
-  inputSchema: lazySchema4(() => zodSchema4(z12.object({}))),
+  inputSchema: lazySchema4(() => zodSchema4(z10.object({}))),
   outputSchema: mcpServerOutputSchema
 });
 var mcpServer = (args) => mcpServerToolFactory(args);
@@ -2199,43 +1269,43 @@ import {
   lazySchema as lazySchema5,
   zodSchema as zodSchema5
 } from "@ai-sdk/provider-utils";
-import { z as z13 } from "zod/v4";
+import { z as z11 } from "zod/v4";
 var webSearchArgsSchema = lazySchema5(
   () => zodSchema5(
-    z13.object({
-      allowedDomains: z13.array(z13.string()).max(5).optional(),
-      excludedDomains: z13.array(z13.string()).max(5).optional(),
-      enableImageSearch: z13.boolean().optional(),
-      enableImageUnderstanding: z13.boolean().optional()
+    z11.object({
+      allowedDomains: z11.array(z11.string()).max(5).optional(),
+      excludedDomains: z11.array(z11.string()).max(5).optional(),
+      enableImageSearch: z11.boolean().optional(),
+      enableImageUnderstanding: z11.boolean().optional()
     })
   )
 );
 var webSearchOutputSchema = lazySchema5(
   () => zodSchema5(
-    z13.object({
-      action: z13.discriminatedUnion("type", [
-        z13.object({
-          type: z13.literal("search"),
-          query: z13.string().optional(),
-          queries: z13.array(z13.string()).optional()
+    z11.object({
+      action: z11.discriminatedUnion("type", [
+        z11.object({
+          type: z11.literal("search"),
+          query: z11.string().optional(),
+          queries: z11.array(z11.string()).optional()
         }),
-        z13.object({
-          type: z13.literal("openPage"),
-          url: z13.string().nullish()
+        z11.object({
+          type: z11.literal("openPage"),
+          url: z11.string().nullish()
         }),
-        z13.object({
-          type: z13.literal("findInPage"),
-          url: z13.string().nullish(),
-          pattern: z13.string().nullish()
+        z11.object({
+          type: z11.literal("findInPage"),
+          url: z11.string().nullish(),
+          pattern: z11.string().nullish()
         })
       ]).optional(),
-      sources: z13.array(z13.object({ type: z13.literal("url"), url: z13.string() })).optional()
+      sources: z11.array(z11.object({ type: z11.literal("url"), url: z11.string() })).optional()
     })
   )
 );
 var webSearchToolFactory = createProviderExecutedToolFactory4({
   id: "xai.web_search",
-  inputSchema: lazySchema5(() => zodSchema5(z13.object({}))),
+  inputSchema: lazySchema5(() => zodSchema5(z11.object({}))),
   outputSchema: webSearchOutputSchema
 });
 var webSearch = (args = {}) => webSearchToolFactory(args);
@@ -2246,29 +1316,29 @@ import {
   lazySchema as lazySchema6,
   zodSchema as zodSchema6
 } from "@ai-sdk/provider-utils";
-import { z as z14 } from "zod/v4";
+import { z as z12 } from "zod/v4";
 var xSearchArgsSchema = lazySchema6(
   () => zodSchema6(
-    z14.object({
-      allowedXHandles: z14.array(z14.string()).max(10).optional(),
-      excludedXHandles: z14.array(z14.string()).max(10).optional(),
-      fromDate: z14.string().optional(),
-      toDate: z14.string().optional(),
-      enableImageUnderstanding: z14.boolean().optional(),
-      enableVideoUnderstanding: z14.boolean().optional()
+    z12.object({
+      allowedXHandles: z12.array(z12.string()).max(10).optional(),
+      excludedXHandles: z12.array(z12.string()).max(10).optional(),
+      fromDate: z12.string().optional(),
+      toDate: z12.string().optional(),
+      enableImageUnderstanding: z12.boolean().optional(),
+      enableVideoUnderstanding: z12.boolean().optional()
     })
   )
 );
 var xSearchOutputSchema = lazySchema6(
   () => zodSchema6(
-    z14.object({
-      query: z14.string(),
-      posts: z14.array(
-        z14.object({
-          author: z14.string(),
-          text: z14.string(),
-          url: z14.string(),
-          likes: z14.number()
+    z12.object({
+      query: z12.string(),
+      posts: z12.array(
+        z12.object({
+          author: z12.string(),
+          text: z12.string(),
+          url: z12.string(),
+          likes: z12.number()
         })
       )
     })
@@ -2276,7 +1346,7 @@ var xSearchOutputSchema = lazySchema6(
 );
 var xSearchToolFactory = createProviderExecutedToolFactory5({
   id: "xai.x_search",
-  inputSchema: lazySchema6(() => zodSchema6(z14.object({}))),
+  inputSchema: lazySchema6(() => zodSchema6(z12.object({}))),
   outputSchema: xSearchOutputSchema
 });
 var xSearch = (args = {}) => xSearchToolFactory(args);
@@ -2436,7 +1506,7 @@ async function prepareResponsesTools({
     }
     default: {
       const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError4({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -2517,13 +1587,13 @@ var XaiResponsesLanguageModel = class _XaiResponsesLanguageModel {
     this.modelId = modelId;
     this.config = config;
   }
-  static [WORKFLOW_SERIALIZE3](model) {
-    return serializeModelOptions3({
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
       modelId: model.modelId,
       config: model.config
     });
   }
-  static [WORKFLOW_DESERIALIZE3](options) {
+  static [WORKFLOW_DESERIALIZE2](options) {
     return new _XaiResponsesLanguageModel(options.modelId, options.config);
   }
   get provider() {
@@ -2550,7 +1620,7 @@ var XaiResponsesLanguageModel = class _XaiResponsesLanguageModel {
   }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const warnings = [];
-    const options = (_a = await parseProviderOptions5({
+    const options = (_a = await parseProviderOptions3({
       provider: "xai",
       providerOptions,
       schema: xaiLanguageModelResponsesOptions
@@ -2608,7 +1678,7 @@ var XaiResponsesLanguageModel = class _XaiResponsesLanguageModel {
       }
     }
     let resolvedReasoningEffort = options.reasoningEffort;
-    if (resolvedReasoningEffort == null && isCustomReasoning2(reasoning)) {
+    if (resolvedReasoningEffort == null && isCustomReasoning(reasoning)) {
       if (!supportsReasoningEffort(modelId)) {
         warnings.push({
           type: "unsupported",
@@ -2618,7 +1688,7 @@ var XaiResponsesLanguageModel = class _XaiResponsesLanguageModel {
       } else if (reasoning === "none") {
         resolvedReasoningEffort = "none";
       } else {
-        resolvedReasoningEffort = mapReasoningToProviderEffort2({
+        resolvedReasoningEffort = mapReasoningToProviderEffort({
           reasoning,
           effortMap: {
             minimal: "low",
@@ -2713,12 +1783,12 @@ var XaiResponsesLanguageModel = class _XaiResponsesLanguageModel {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await postJsonToApi3({
+    } = await postJsonToApi2({
       url: `${(_a = this.config.baseURL) != null ? _a : "https://api.x.ai/v1"}/responses`,
-      headers: combineHeaders3((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
+      headers: combineHeaders2((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler3(
+      successfulResponseHandler: createJsonResponseHandler2(
         xaiResponsesResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -2931,12 +2001,12 @@ var XaiResponsesLanguageModel = class _XaiResponsesLanguageModel {
       ...args,
       stream: true
     };
-    const { responseHeaders, value: response } = await postJsonToApi3({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: `${(_a = this.config.baseURL) != null ? _a : "https://api.x.ai/v1"}/responses`,
-      headers: combineHeaders3((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
+      headers: combineHeaders2((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler2(
+      successfulResponseHandler: createEventSourceResponseHandler(
         xaiResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -3505,13 +2575,13 @@ var xaiBatchName = "ai-sdk-text-batch";
 var xaiBatchResultsPageSize = 1e3;
 var xaiBatchProviderOptionsSchema = lazySchema7(
   () => zodSchema7(
-    z15.object({
+    z13.object({
       /**
        * TTL in seconds for the uploaded batch input file, measured from
        * upload time. xAI accepts integers between 3600 (1 hour) and
        * 2592000 (30 days) inclusive. Without it the file has no expiry.
        */
-      inputFileExpiresAfter: z15.number().int().min(3600).max(2592e3).optional()
+      inputFileExpiresAfter: z13.number().int().min(3600).max(2592e3).optional()
     })
   )
 );
@@ -3519,70 +2589,108 @@ function assertSupportedBatchRequests(requests) {
   for (const request of requests) {
     const requestType = request.type;
     if (requestType !== "text" && requestType !== "image") {
-      throw new UnsupportedFunctionalityError5({
+      throw new UnsupportedFunctionalityError3({
         functionality: `batch request type: ${requestType}`,
         message: `The xAI Batch API does not support batch requests with type "${requestType}".`
       });
     }
   }
 }
-var xaiBatchImageResponseSchema = z15.object({
-  data: z15.array(
-    z15.object({
-      url: z15.string().nullish(),
-      b64_json: z15.string().nullish(),
-      revised_prompt: z15.string().nullish(),
-      respect_moderation: z15.boolean().nullish()
+var xaiBatchImageResponseSchema = z13.object({
+  data: z13.array(
+    z13.object({
+      url: z13.string().nullish(),
+      b64_json: z13.string().nullish(),
+      revised_prompt: z13.string().nullish(),
+      respect_moderation: z13.boolean().nullish()
     })
   ),
-  usage: z15.object({ cost_in_usd_ticks: z15.number().nullish() }).nullish()
+  usage: z13.object({ cost_in_usd_ticks: z13.number().nullish() }).nullish()
 });
-var xaiBatchResponseZodSchema = () => z15.object({
-  batch_id: z15.string(),
-  name: z15.string().nullish(),
-  create_time: z15.string().nullish(),
-  expire_time: z15.string().nullish(),
-  cancel_time: z15.string().nullish(),
-  cancel_by_xai_message: z15.string().nullish(),
-  state: z15.object({
-    num_requests: z15.number().nullish(),
-    num_pending: z15.number().nullish(),
-    num_success: z15.number().nullish(),
-    num_error: z15.number().nullish(),
-    num_cancelled: z15.number().nullish()
+var xaiBatchResponseZodSchema = () => z13.object({
+  batch_id: z13.string(),
+  name: z13.string().nullish(),
+  create_time: z13.string().nullish(),
+  expire_time: z13.string().nullish(),
+  cancel_time: z13.string().nullish(),
+  cancel_by_xai_message: z13.string().nullish(),
+  state: z13.object({
+    num_requests: z13.number().nullish(),
+    num_pending: z13.number().nullish(),
+    num_success: z13.number().nullish(),
+    num_error: z13.number().nullish(),
+    num_cancelled: z13.number().nullish()
   }).nullish()
 });
 var xaiBatchResponseSchema = lazySchema7(
   () => zodSchema7(xaiBatchResponseZodSchema())
 );
-var xaiBatchErrorSchema = z15.object({
-  code: z15.union([z15.string(), z15.number()]).nullish(),
-  message: z15.string().nullish()
+var xaiBatchErrorSchema = z13.object({
+  code: z13.union([z13.string(), z13.number()]).nullish(),
+  message: z13.string().nullish()
 });
-var xaiBatchResultSchema = z15.object({
-  batch_request_id: z15.string(),
-  batch_result: z15.object({
-    response: z15.object({
-      chat_get_completion: z15.unknown().nullish(),
-      image_generation: z15.unknown().nullish()
+var xaiBatchResultSchema = z13.object({
+  batch_request_id: z13.string(),
+  batch_result: z13.object({
+    response: z13.object({
+      chat_get_completion: z13.unknown().nullish(),
+      image_generation: z13.unknown().nullish()
     }).nullish(),
     error: xaiBatchErrorSchema.nullish()
   }).nullish(),
-  error_message: z15.string().nullish()
+  error_message: z13.string().nullish()
+});
+var xaiBatchTextResponseSchema = z13.object({
+  id: z13.string().nullish(),
+  created: z13.number().nullish(),
+  model: z13.string().nullish(),
+  choices: z13.array(
+    z13.object({
+      message: z13.object({
+        role: z13.enum(["assistant", "tool"]),
+        content: z13.string().nullish(),
+        reasoning_content: z13.string().nullish(),
+        tool_calls: z13.array(
+          z13.object({
+            id: z13.string(),
+            type: z13.literal("function"),
+            function: z13.object({
+              name: z13.string(),
+              arguments: z13.string()
+            })
+          })
+        ).nullish()
+      }),
+      index: z13.number(),
+      finish_reason: z13.string().nullish()
+    })
+  ).nullish(),
+  usage: z13.object({
+    prompt_tokens: z13.number(),
+    completion_tokens: z13.number(),
+    total_tokens: z13.number(),
+    cost_in_usd_ticks: z13.number().nullish(),
+    prompt_tokens_details: z13.object({ cached_tokens: z13.number().nullish() }).nullish(),
+    completion_tokens_details: z13.object({ reasoning_tokens: z13.number().nullish() }).nullish()
+  }).nullish(),
+  citations: z13.array(z13.string().url()).nullish(),
+  service_tier: z13.string().nullish(),
+  code: z13.string().nullish(),
+  error: z13.string().nullish()
 });
 var xaiBatchResultsPageSchema = lazySchema7(
   () => zodSchema7(
-    z15.object({
-      results: z15.array(xaiBatchResultSchema),
-      pagination_token: z15.string().nullish()
+    z13.object({
+      results: z13.array(xaiBatchResultSchema),
+      pagination_token: z13.string().nullish()
     })
   )
 );
 var xaiBatchListResponseSchema = lazySchema7(
   () => zodSchema7(
-    z15.object({
-      batches: z15.array(xaiBatchResponseZodSchema()),
-      pagination_token: z15.string().nullish()
+    z13.object({
+      batches: z13.array(xaiBatchResponseZodSchema()),
+      pagination_token: z13.string().nullish()
     })
   )
 );
@@ -3606,7 +2714,7 @@ var XaiBatch = class {
         }
       }
     ];
-    const batchOptions = await parseProviderOptions6({
+    const batchOptions = await parseProviderOptions4({
       provider: "xai",
       providerOptions: options.providerOptions,
       schema: xaiBatchProviderOptionsSchema
@@ -3637,7 +2745,7 @@ var XaiBatch = class {
       );
     }
     formData.append("file", file, filename);
-    const headers = combineHeaders4(
+    const headers = combineHeaders3(
       (_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a),
       options.headers
     );
@@ -3646,13 +2754,13 @@ var XaiBatch = class {
       headers,
       formData,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
+      successfulResponseHandler: createJsonResponseHandler3(
         xaiFilesResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.options.config.fetch
     });
-    const { value: batch } = await postJsonToApi4({
+    const { value: batch } = await postJsonToApi3({
       url: this.getUrl("/batches"),
       headers,
       body: {
@@ -3660,7 +2768,7 @@ var XaiBatch = class {
         input_file_id: uploadedFile.id
       },
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
+      successfulResponseHandler: createJsonResponseHandler3(
         xaiBatchResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -3687,14 +2795,14 @@ var XaiBatch = class {
   }
   async doCancelBatch(options) {
     var _a, _b;
-    await postJsonToApi4({
+    await postJsonToApi3({
       url: this.getUrl(
         `/batches/${encodeURIComponent(options.batchId)}:cancel`
       ),
-      headers: combineHeaders4((_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      headers: combineHeaders3((_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: {},
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
+      successfulResponseHandler: createJsonResponseHandler3(
         xaiBatchResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -3713,9 +2821,9 @@ var XaiBatch = class {
     }
     const { value: page } = await getFromApi2({
       url: url.toString(),
-      headers: combineHeaders4((_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      headers: combineHeaders3((_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
+      successfulResponseHandler: createJsonResponseHandler3(
         xaiBatchListResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -3746,9 +2854,9 @@ var XaiBatch = class {
     var _a, _b;
     const { value: batch } = await getFromApi2({
       url: this.getUrl(`/batches/${encodeURIComponent(options.batchId)}`),
-      headers: combineHeaders4((_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a), options.headers),
+      headers: combineHeaders3((_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler4(
+      successfulResponseHandler: createJsonResponseHandler3(
         xaiBatchResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -3771,12 +2879,12 @@ var XaiBatch = class {
         url: this.getUrl(
           `/batches/${encodeURIComponent(options.batchId)}/results?${query}`
         ),
-        headers: combineHeaders4(
+        headers: combineHeaders3(
           (_b = (_a = this.options.config).headers) == null ? void 0 : _b.call(_a),
           options.headers
         ),
         failedResponseHandler: xaiFailedResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler4(
+        successfulResponseHandler: createJsonResponseHandler3(
           xaiBatchResultsPageSchema
         ),
         abortSignal: options.abortSignal,
@@ -3805,12 +2913,12 @@ var XaiBatch = class {
     if ((response == null ? void 0 : response.chat_get_completion) != null) {
       const validation = await safeValidateTypes({
         value: response.chat_get_completion,
-        schema: xaiChatResponseSchema
+        schema: zodSchema7(xaiBatchTextResponseSchema)
       });
       if (!validation.success) {
         return invalidXaiBatchResult(result.batch_request_id);
       }
-      const conversion = convertXaiChatBatchResponse(validation.value);
+      const conversion = convertXaiBatchTextResponse(validation.value);
       return conversion.success ? {
         type: "text",
         id: result.batch_request_id,
@@ -3873,7 +2981,7 @@ var XaiBatch = class {
     }
     if (seed != null) warnings.push({ type: "unsupported", feature: "seed" });
     if (mask != null) warnings.push({ type: "unsupported", feature: "mask" });
-    const xaiOptions = await parseProviderOptions6({
+    const xaiOptions = await parseProviderOptions4({
       provider: "xai",
       providerOptions,
       schema: xaiImageModelOptions
@@ -4020,7 +3128,7 @@ function invalidXaiImageBatchResult(id) {
     }
   };
 }
-function convertXaiChatBatchResponse(response) {
+function convertXaiBatchTextResponse(response) {
   var _a, _b, _c, _d, _e, _f;
   if (response.error != null) {
     return {
@@ -4102,7 +3210,7 @@ function convertXaiChatBatchResponse(response) {
         unified: mapXaiFinishReason(lastAssistantChoice == null ? void 0 : lastAssistantChoice.finish_reason),
         raw: (_d = lastAssistantChoice == null ? void 0 : lastAssistantChoice.finish_reason) != null ? _d : void 0
       },
-      usage: response.usage ? convertXaiChatUsage(response.usage) : createNullLanguageModelUsage(),
+      usage: response.usage ? convertXaiBatchTextUsage(response.usage) : createNullLanguageModelUsage(),
       response: getResponseMetadata(response),
       warnings: [],
       ...(((_e = response.usage) == null ? void 0 : _e.cost_in_usd_ticks) != null || response.service_tier != null) && {
@@ -4116,6 +3224,26 @@ function convertXaiChatBatchResponse(response) {
     }
   };
 }
+function convertXaiBatchTextUsage(usage) {
+  var _a, _b, _c, _d;
+  const cacheReadTokens = (_b = (_a = usage.prompt_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0;
+  const reasoningTokens = (_d = (_c = usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
+  const promptTokensIncludesCached = cacheReadTokens <= usage.prompt_tokens;
+  return {
+    inputTokens: {
+      total: promptTokensIncludesCached ? usage.prompt_tokens : usage.prompt_tokens + cacheReadTokens,
+      noCache: promptTokensIncludesCached ? usage.prompt_tokens - cacheReadTokens : usage.prompt_tokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: usage.completion_tokens + reasoningTokens,
+      text: usage.completion_tokens,
+      reasoning: reasoningTokens
+    },
+    raw: usage
+  };
+}
 
 // src/realtime/xai-realtime-event-mapper.ts
 function parseXaiRealtimeServerEvent(raw) {
@@ -4488,43 +3616,43 @@ var XaiRealtimeModel = class {
 
 // src/tool/code-execution.ts
 import { createProviderExecutedToolFactory as createProviderExecutedToolFactory6 } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
-var codeExecutionOutputSchema = z16.object({
-  output: z16.string().describe("the output of the code execution"),
-  error: z16.string().optional().describe("any error that occurred")
+import { z as z14 } from "zod/v4";
+var codeExecutionOutputSchema = z14.object({
+  output: z14.string().describe("the output of the code execution"),
+  error: z14.string().optional().describe("any error that occurred")
 });
 var codeExecutionToolFactory = createProviderExecutedToolFactory6({
   id: "xai.code_execution",
-  inputSchema: z16.object({}).describe("no input parameters"),
+  inputSchema: z14.object({}).describe("no input parameters"),
   outputSchema: codeExecutionOutputSchema
 });
 var codeExecution = (args = {}) => codeExecutionToolFactory(args);
 
 // src/tool/view-image.ts
 import { createProviderExecutedToolFactory as createProviderExecutedToolFactory7 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
-var viewImageOutputSchema = z17.object({
-  description: z17.string().describe("description of the image"),
-  objects: z17.array(z17.string()).optional().describe("objects detected in the image")
+import { z as z15 } from "zod/v4";
+var viewImageOutputSchema = z15.object({
+  description: z15.string().describe("description of the image"),
+  objects: z15.array(z15.string()).optional().describe("objects detected in the image")
 });
 var viewImageToolFactory = createProviderExecutedToolFactory7({
   id: "xai.view_image",
-  inputSchema: z17.object({}).describe("no input parameters"),
+  inputSchema: z15.object({}).describe("no input parameters"),
   outputSchema: viewImageOutputSchema
 });
 var viewImage = (args = {}) => viewImageToolFactory(args);
 
 // src/tool/view-x-video.ts
 import { createProviderExecutedToolFactory as createProviderExecutedToolFactory8 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var viewXVideoOutputSchema = z18.object({
-  transcript: z18.string().optional().describe("transcript of the video"),
-  description: z18.string().describe("description of the video content"),
-  duration: z18.number().optional().describe("duration in seconds")
+import { z as z16 } from "zod/v4";
+var viewXVideoOutputSchema = z16.object({
+  transcript: z16.string().optional().describe("transcript of the video"),
+  description: z16.string().describe("description of the video content"),
+  duration: z16.number().optional().describe("duration in seconds")
 });
 var viewXVideoToolFactory = createProviderExecutedToolFactory8({
   id: "xai.view_x_video",
-  inputSchema: z18.object({}).describe("no input parameters"),
+  inputSchema: z16.object({}).describe("no input parameters"),
   outputSchema: viewXVideoOutputSchema
 });
 var viewXVideo = (args = {}) => viewXVideoToolFactory(args);
@@ -4542,20 +3670,20 @@ var xaiTools = {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.59" : "0.0.0-test";
+var VERSION = true ? "5.0.1" : "0.0.0-test";
 
 // src/files/xai-files.ts
 import {
   InvalidArgumentError as InvalidArgumentError2
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders5,
+  combineHeaders as combineHeaders4,
   convertInlineFileDataToUint8Array,
   createBinaryStreamResponseHandler,
-  createJsonResponseHandler as createJsonResponseHandler5,
+  createJsonResponseHandler as createJsonResponseHandler4,
   deleteFromApi,
   getFromApi as getFromApi3,
-  parseProviderOptions as parseProviderOptions7,
+  parseProviderOptions as parseProviderOptions5,
   postFormDataToApi as postFormDataToApi2,
   postMultipartStreamToApi
 } from "@ai-sdk/provider-utils";
@@ -4565,18 +3693,18 @@ import {
   lazySchema as lazySchema8,
   zodSchema as zodSchema8
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
+import { z as z17 } from "zod/v4";
 var xaiFilesOptionsSchema = lazySchema8(
   () => zodSchema8(
-    z19.looseObject({
-      teamId: z19.string().optional(),
-      filePath: z19.string().optional(),
+    z17.looseObject({
+      teamId: z17.string().optional(),
+      filePath: z17.string().optional(),
       /**
        * TTL in seconds measured from upload time; xAI accepts integers
        * between 3600 (1 hour) and 2592000 (30 days) inclusive.
        * Omit to keep the file until it is deleted.
        */
-      expiresAfter: z19.number().int().min(3600).max(2592e3).optional()
+      expiresAfter: z17.number().int().min(3600).max(2592e3).optional()
     })
   )
 );
@@ -4605,7 +3733,7 @@ var XaiFiles = class {
     return fileId;
   }
   getHeaders(headers) {
-    return combineHeaders5(this.config.headers(), headers);
+    return combineHeaders4(this.config.headers(), headers);
   }
   async uploadFile({
     data,
@@ -4618,7 +3746,7 @@ var XaiFiles = class {
     var _a, _b;
     let xaiOptions;
     try {
-      xaiOptions = await parseProviderOptions7({
+      xaiOptions = await parseProviderOptions5({
         provider: "xai",
         providerOptions,
         schema: xaiFilesOptionsSchema
@@ -4661,7 +3789,7 @@ var XaiFiles = class {
         headers: requestHeaders,
         parts,
         failedResponseHandler: xaiFailedResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler5(
+        successfulResponseHandler: createJsonResponseHandler4(
           xaiFilesResponseSchema
         ),
         abortSignal,
@@ -4689,7 +3817,7 @@ var XaiFiles = class {
         headers: requestHeaders,
         formData,
         failedResponseHandler: xaiFailedResponseHandler,
-        successfulResponseHandler: createJsonResponseHandler5(
+        successfulResponseHandler: createJsonResponseHandler4(
           xaiFilesResponseSchema
         ),
         abortSignal,
@@ -4719,7 +3847,7 @@ var XaiFiles = class {
       url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}`,
       headers: this.getHeaders(headers),
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler5(
+      successfulResponseHandler: createJsonResponseHandler4(
         xaiFilesResponseSchema
       ),
       abortSignal,
@@ -4771,7 +3899,7 @@ var XaiFiles = class {
       url: `${this.config.baseURL}/files/${encodePathSegment(fileId)}`,
       headers: this.getHeaders(headers),
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler5(
+      successfulResponseHandler: createJsonResponseHandler4(
         xaiFileDeleteResponseSchema
       ),
       abortSignal,
@@ -4798,38 +3926,38 @@ var XaiFiles = class {
 // src/xai-video-model.ts
 import {
   AISDKError,
-  APICallError as APICallError2
+  APICallError
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders6,
+  combineHeaders as combineHeaders5,
   convertUint8ArrayToBase64,
-  createJsonResponseHandler as createJsonResponseHandler6,
-  extractResponseHeaders as extractResponseHeaders2,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  extractResponseHeaders,
   getFromApi as getFromApi4,
-  getTopLevelMediaType as getTopLevelMediaType3,
-  parseProviderOptions as parseProviderOptions8,
-  postJsonToApi as postJsonToApi5,
-  safeParseJSON as safeParseJSON2
+  getTopLevelMediaType as getTopLevelMediaType2,
+  parseProviderOptions as parseProviderOptions6,
+  postJsonToApi as postJsonToApi4,
+  safeParseJSON
 } from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
+import { z as z19 } from "zod/v4";
 
 // src/xai-video-model-options.ts
 import { lazySchema as lazySchema9, zodSchema as zodSchema9 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
-var nonEmptyStringSchema = z20.string().min(1);
-var resolutionSchema = z20.enum(["480p", "720p", "1080p"]);
-var modeSchema = z20.enum(["edit-video", "extend-video", "reference-to-video"]);
+import { z as z18 } from "zod/v4";
+var nonEmptyStringSchema = z18.string().min(1);
+var resolutionSchema = z18.enum(["480p", "720p", "1080p"]);
+var modeSchema = z18.enum(["edit-video", "extend-video", "reference-to-video"]);
 var baseFields = {
-  pollIntervalMs: z20.number().positive().nullish(),
-  pollTimeoutMs: z20.number().positive().nullish(),
+  pollIntervalMs: z18.number().positive().nullish(),
+  pollTimeoutMs: z18.number().positive().nullish(),
   resolution: resolutionSchema.nullish()
 };
-var runtimeSchema = z20.looseObject({
+var runtimeSchema = z18.looseObject({
   mode: modeSchema.optional(),
   videoUrl: nonEmptyStringSchema.optional(),
-  referenceImageUrls: z20.array(nonEmptyStringSchema).min(1).max(7).optional(),
-  referenceVoiceIds: z20.array(nonEmptyStringSchema).max(3).optional(),
-  user: z20.string().optional(),
+  referenceImageUrls: z18.array(nonEmptyStringSchema).min(1).max(7).optional(),
+  referenceVoiceIds: z18.array(nonEmptyStringSchema).max(3).optional(),
+  user: z18.string().optional(),
   ...baseFields
 });
 var xaiVideoModelOptionsSchema = lazySchema9(
@@ -4859,8 +3987,8 @@ function resolveStartImage(options) {
   var _a;
   return (_a = getFirstFrameImage(options)) != null ? _a : options.image;
 }
-var isVideoFile = (file) => file.mediaType != null && getTopLevelMediaType3(file.mediaType) === "video";
-var isImageReference = (file) => file.mediaType == null || getTopLevelMediaType3(file.mediaType) === "image";
+var isVideoFile = (file) => file.mediaType != null && getTopLevelMediaType2(file.mediaType) === "video";
+var isImageReference = (file) => file.mediaType == null || getTopLevelMediaType2(file.mediaType) === "image";
 function fileToXaiUrl(file) {
   if (file.type === "url") {
     return file.url;
@@ -4919,7 +4047,7 @@ var XaiVideoModel = class {
   }
   async buildRequestBody(options) {
     const warnings = [];
-    const xaiOptions = await parseProviderOptions8({
+    const xaiOptions = await parseProviderOptions6({
       provider: "xai",
       providerOptions: options.providerOptions,
       schema: xaiVideoModelOptionsSchema
@@ -5127,12 +4255,12 @@ var XaiVideoModel = class {
     } else {
       endpoint = `${baseURL}/videos/generations`;
     }
-    const { value: createResponse, responseHeaders } = await postJsonToApi5({
+    const { value: createResponse, responseHeaders } = await postJsonToApi4({
       url: endpoint,
-      headers: combineHeaders6(this.config.headers(), options.headers),
+      headers: combineHeaders5(this.config.headers(), options.headers),
       body,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler6(
+      successfulResponseHandler: createJsonResponseHandler5(
         xaiCreateVideoResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -5163,7 +4291,7 @@ var XaiVideoModel = class {
     const { value: statusResponse, responseHeaders } = await getFromApi4({
       url: `${baseURL}/videos/${encodePathSegment2(requestId)}`,
       validateUrl: false,
-      headers: combineHeaders6(this.config.headers(), options.headers),
+      headers: combineHeaders5(this.config.headers(), options.headers),
       successfulResponseHandler: xaiVideoStatusResponseHandler,
       failedResponseHandler: xaiFailedResponseHandler,
       abortSignal: options.abortSignal,
@@ -5251,27 +4379,27 @@ var XaiVideoModel = class {
     };
   }
 };
-var xaiCreateVideoResponseSchema = z21.object({
-  request_id: z21.string().nullish()
+var xaiCreateVideoResponseSchema = z19.object({
+  request_id: z19.string().nullish()
 });
-var xaiVideoStatusResponseSchema = z21.object({
-  status: z21.string().nullish(),
-  video: z21.object({
-    url: z21.string(),
-    duration: z21.number().nullish(),
-    respect_moderation: z21.boolean().nullish()
+var xaiVideoStatusResponseSchema = z19.object({
+  status: z19.string().nullish(),
+  video: z19.object({
+    url: z19.string(),
+    duration: z19.number().nullish(),
+    respect_moderation: z19.boolean().nullish()
   }).nullish(),
-  model: z21.string().nullish(),
-  usage: z21.object({
-    cost_in_usd_ticks: z21.number().nullish()
+  model: z19.string().nullish(),
+  usage: z19.object({
+    cost_in_usd_ticks: z19.number().nullish()
   }).nullish(),
-  progress: z21.number().nullish(),
-  error: z21.object({
-    code: z21.string().nullish(),
-    message: z21.string().nullish()
+  progress: z19.number().nullish(),
+  error: z19.object({
+    code: z19.string().nullish(),
+    message: z19.string().nullish()
   }).nullish()
 });
-var xaiVideoStatusJsonResponseHandler = createJsonResponseHandler6(
+var xaiVideoStatusJsonResponseHandler = createJsonResponseHandler5(
   xaiVideoStatusResponseSchema
 );
 var MAX_PENDING_BODY_BYTES = 1024 * 1024;
@@ -5293,12 +4421,12 @@ async function readPendingBody({
       if (done) break;
       totalBytes += value.length;
       if (totalBytes > MAX_PENDING_BODY_BYTES) {
-        throw new APICallError2({
+        throw new APICallError({
           message: `xAI video status response exceeded ${MAX_PENDING_BODY_BYTES} bytes`,
           url,
           requestBodyValues,
           statusCode: response.status,
-          responseHeaders: extractResponseHeaders2(response)
+          responseHeaders: extractResponseHeaders(response)
         });
       }
       chunks.push(value);
@@ -5316,12 +4444,12 @@ async function readPendingBody({
 }
 var xaiVideoStatusResponseHandler = async (options) => {
   if (options.response.status === 202) {
-    const responseHeaders = extractResponseHeaders2(options.response);
+    const responseHeaders = extractResponseHeaders(options.response);
     const text = await readPendingBody(options);
     if (text.trim().length === 0) {
       return { responseHeaders, value: { status: "pending" } };
     }
-    const parsed = await safeParseJSON2({
+    const parsed = await safeParseJSON({
       text,
       schema: xaiVideoStatusResponseSchema
     });
@@ -5335,69 +4463,69 @@ var xaiVideoStatusResponseHandler = async (options) => {
 
 // src/xai-speech-model.ts
 import {
-  combineHeaders as combineHeaders7,
+  combineHeaders as combineHeaders6,
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
   createBinaryResponseHandler as createBinaryResponseHandler3,
-  createJsonResponseHandler as createJsonResponseHandler7,
-  parseProviderOptions as parseProviderOptions9,
-  postJsonToApi as postJsonToApi6,
+  createJsonResponseHandler as createJsonResponseHandler6,
+  parseProviderOptions as parseProviderOptions7,
+  postJsonToApi as postJsonToApi5,
   resolve,
-  serializeModelOptions as serializeModelOptions4,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE4,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE4
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3
 } from "@ai-sdk/provider-utils";
-import { z as z23 } from "zod/v4";
+import { z as z21 } from "zod/v4";
 
 // src/xai-speech-model-options.ts
 import {
   lazySchema as lazySchema10,
   zodSchema as zodSchema10
 } from "@ai-sdk/provider-utils";
-import { z as z22 } from "zod/v4";
+import { z as z20 } from "zod/v4";
 var xaiSpeechModelOptionsSchema = lazySchema10(
   () => zodSchema10(
-    z22.object({
+    z20.object({
       /**
        * Sample rate of the generated audio in Hz.
        */
-      sampleRate: z22.union([
-        z22.literal(8e3),
-        z22.literal(16e3),
-        z22.literal(22050),
-        z22.literal(24e3),
-        z22.literal(44100),
-        z22.literal(48e3)
+      sampleRate: z20.union([
+        z20.literal(8e3),
+        z20.literal(16e3),
+        z20.literal(22050),
+        z20.literal(24e3),
+        z20.literal(44100),
+        z20.literal(48e3)
       ]).nullish(),
       /**
        * MP3 bit rate in bits per second. Only applies when outputFormat is mp3.
        */
-      bitRate: z22.union([
-        z22.literal(32e3),
-        z22.literal(64e3),
-        z22.literal(96e3),
-        z22.literal(128e3),
-        z22.literal(192e3)
+      bitRate: z20.union([
+        z20.literal(32e3),
+        z20.literal(64e3),
+        z20.literal(96e3),
+        z20.literal(128e3),
+        z20.literal(192e3)
       ]).nullish(),
       /**
        * Reduce time to first audio chunk, trading some quality for latency.
        */
-      optimizeStreamingLatency: z22.union([z22.literal(0), z22.literal(1), z22.literal(2)]).nullish(),
+      optimizeStreamingLatency: z20.union([z20.literal(0), z20.literal(1), z20.literal(2)]).nullish(),
       /**
        * Normalize written-form text into spoken-form text before synthesis.
        */
-      textNormalization: z22.boolean().nullish(),
+      textNormalization: z20.boolean().nullish(),
       /**
        * Return character-level timing metadata alongside the audio. When
        * enabled, the response carries per-character start/end times and the
        * total duration, exposed via `providerMetadata.xai`.
        */
-      withTimestamps: z22.boolean().nullish(),
+      withTimestamps: z20.boolean().nullish(),
       /**
        * Map of phrases to spoken substitutions applied before synthesis.
        * Values may be respellings (`{ 'Acme Mobile': 'Acme Mobull' }`) or IPA
        * phonetics (`{ nginx: '/ˈɛndʒɪn ˈɛks/' }`).
        */
-      replace: z22.record(z22.string(), z22.string()).nullish()
+      replace: z20.record(z20.string(), z20.string()).nullish()
     })
   )
 );
@@ -5409,13 +4537,13 @@ var XaiSpeechModel = class _XaiSpeechModel {
     this.config = config;
     this.specificationVersion = "v4";
   }
-  static [WORKFLOW_SERIALIZE4](model) {
-    return serializeModelOptions4({
+  static [WORKFLOW_SERIALIZE3](model) {
+    return serializeModelOptions3({
       modelId: model.modelId,
       config: model.config
     });
   }
-  static [WORKFLOW_DESERIALIZE4](options) {
+  static [WORKFLOW_DESERIALIZE3](options) {
     return new _XaiSpeechModel(options.modelId, options.config);
   }
   get provider() {
@@ -5431,7 +4559,7 @@ var XaiSpeechModel = class _XaiSpeechModel {
     providerOptions
   }) {
     const warnings = [];
-    const xaiOptions = await parseProviderOptions9({
+    const xaiOptions = await parseProviderOptions7({
       provider: "xai",
       providerOptions,
       schema: xaiSpeechModelOptionsSchema
@@ -5491,15 +4619,15 @@ var XaiSpeechModel = class _XaiSpeechModel {
     var _a, _b, _c;
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     const { requestBody, warnings, withTimestamps } = await this.getArgs(options);
-    const { value, responseHeaders, rawValue } = await postJsonToApi6({
+    const { value, responseHeaders, rawValue } = await postJsonToApi5({
       url: `${this.config.baseURL}/tts`,
-      headers: combineHeaders7(
+      headers: combineHeaders6(
         this.config.headers ? await resolve(this.config.headers) : void 0,
         options.headers
       ),
       body: requestBody,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: withTimestamps ? createJsonResponseHandler7(xaiSpeechTimestampsResponseSchema) : createBinaryResponseHandler3(),
+      successfulResponseHandler: withTimestamps ? createJsonResponseHandler6(xaiSpeechTimestampsResponseSchema) : createBinaryResponseHandler3(),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -5540,13 +4668,13 @@ var XaiSpeechModel = class _XaiSpeechModel {
     };
   }
 };
-var xaiSpeechTimestampsResponseSchema = z23.object({
-  audio: z23.string().nullish(),
-  content_type: z23.string().nullish(),
-  duration: z23.number().nullish(),
-  audio_timestamps: z23.object({
-    graph_chars: z23.array(z23.string()),
-    graph_times: z23.array(z23.tuple([z23.number(), z23.number()]))
+var xaiSpeechTimestampsResponseSchema = z21.object({
+  audio: z21.string().nullish(),
+  content_type: z21.string().nullish(),
+  duration: z21.number().nullish(),
+  audio_timestamps: z21.object({
+    graph_chars: z21.array(z21.string()),
+    graph_times: z21.array(z21.tuple([z21.number(), z21.number()]))
   }).nullish()
 });
 
@@ -5555,94 +4683,94 @@ import {
   InvalidArgumentError as InvalidArgumentError3
 } from "@ai-sdk/provider";
 import {
-  combineHeaders as combineHeaders8,
+  combineHeaders as combineHeaders7,
   convertBase64ToUint8Array as convertBase64ToUint8Array3,
-  createJsonResponseHandler as createJsonResponseHandler8,
+  createJsonResponseHandler as createJsonResponseHandler7,
   connectToWebSocket,
   mediaTypeToExtension,
-  parseProviderOptions as parseProviderOptions10,
+  parseProviderOptions as parseProviderOptions8,
   postFormDataToApi as postFormDataToApi3,
-  safeParseJSON as safeParseJSON3,
-  serializeModelOptions as serializeModelOptions5,
+  safeParseJSON as safeParseJSON2,
+  serializeModelOptions as serializeModelOptions4,
   toWebSocketUrl,
   waitForWebSocketBufferDrain,
-  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE5,
-  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE5
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE4,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE4
 } from "@ai-sdk/provider-utils";
-import { z as z25 } from "zod/v4";
+import { z as z23 } from "zod/v4";
 
 // src/xai-transcription-model-options.ts
 import {
   lazySchema as lazySchema11,
   zodSchema as zodSchema11
 } from "@ai-sdk/provider-utils";
-import { z as z24 } from "zod/v4";
+import { z as z22 } from "zod/v4";
 var xaiTranscriptionModelOptionsSchema = lazySchema11(
   () => zodSchema11(
-    z24.object({
+    z22.object({
       /**
        * Audio encoding for raw, headerless input audio.
        */
-      audioFormat: z24.enum(["pcm", "mulaw", "alaw"]).nullish(),
+      audioFormat: z22.enum(["pcm", "mulaw", "alaw"]).nullish(),
       /**
        * Sample rate of the input audio in Hz.
        */
-      sampleRate: z24.union([
-        z24.literal(8e3),
-        z24.literal(16e3),
-        z24.literal(22050),
-        z24.literal(24e3),
-        z24.literal(44100),
-        z24.literal(48e3)
+      sampleRate: z22.union([
+        z22.literal(8e3),
+        z22.literal(16e3),
+        z22.literal(22050),
+        z22.literal(24e3),
+        z22.literal(44100),
+        z22.literal(48e3)
       ]).nullish(),
       /**
        * Language code used for inverse text normalization.
        */
-      language: z24.string().nullish(),
+      language: z22.string().nullish(),
       /**
        * Enable inverse text normalization. Requires `language`.
        */
-      format: z24.boolean().nullish(),
+      format: z22.boolean().nullish(),
       /**
        * Enable per-channel transcription for multichannel audio.
        */
-      multichannel: z24.boolean().nullish(),
+      multichannel: z22.boolean().nullish(),
       /**
        * Number of interleaved audio channels.
        */
-      channels: z24.number().int().min(2).max(8).nullish(),
+      channels: z22.number().int().min(2).max(8).nullish(),
       /**
        * Enable speaker diarization.
        */
-      diarize: z24.boolean().nullish(),
+      diarize: z22.boolean().nullish(),
       /**
        * Terms to bias transcription toward.
        */
-      keyterm: z24.union([z24.string(), z24.array(z24.string())]).nullish(),
+      keyterm: z22.union([z22.string(), z22.array(z22.string())]).nullish(),
       /**
        * Include filler words such as "uh" and "um" in the transcript.
        */
-      fillerWords: z24.boolean().nullish(),
+      fillerWords: z22.boolean().nullish(),
       /**
        * Options for streaming speech-to-text over WebSocket.
        */
-      streaming: z24.object({
+      streaming: z22.object({
         /**
          * Emit interim transcript results while speech is being processed.
          */
-        interimResults: z24.boolean().optional(),
+        interimResults: z22.boolean().optional(),
         /**
          * Silence duration in milliseconds before an utterance-final event.
          */
-        endpointing: z24.number().int().min(0).max(5e3).optional(),
+        endpointing: z22.number().int().min(0).max(5e3).optional(),
         /**
          * End-of-turn detection threshold. When set, enables Smart Turn.
          */
-        smartTurn: z24.number().min(0).max(1).optional(),
+        smartTurn: z22.number().min(0).max(1).optional(),
         /**
          * Maximum silence duration in milliseconds before forcing speech_final.
          */
-        smartTurnTimeout: z24.number().int().min(1).max(5e3).optional()
+        smartTurnTimeout: z22.number().int().min(1).max(5e3).optional()
       }).optional()
     })
   )
@@ -5655,13 +4783,13 @@ var XaiTranscriptionModel = class _XaiTranscriptionModel {
     this.config = config;
     this.specificationVersion = "v4";
   }
-  static [WORKFLOW_SERIALIZE5](model) {
-    return serializeModelOptions5({
+  static [WORKFLOW_SERIALIZE4](model) {
+    return serializeModelOptions4({
       modelId: model.modelId,
       config: model.config
     });
   }
-  static [WORKFLOW_DESERIALIZE5](options) {
+  static [WORKFLOW_DESERIALIZE4](options) {
     return new _XaiTranscriptionModel(options.modelId, options.config);
   }
   get provider() {
@@ -5673,7 +4801,7 @@ var XaiTranscriptionModel = class _XaiTranscriptionModel {
     providerOptions
   }) {
     const warnings = [];
-    const xaiOptions = await parseProviderOptions10({
+    const xaiOptions = await parseProviderOptions8({
       provider: "xai",
       providerOptions,
       schema: xaiTranscriptionModelOptionsSchema
@@ -5719,10 +4847,10 @@ var XaiTranscriptionModel = class _XaiTranscriptionModel {
       rawValue: rawResponse
     } = await postFormDataToApi3({
       url: `${(_d = this.config.baseURL) != null ? _d : "https://api.x.ai/v1"}/stt`,
-      headers: combineHeaders8((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), options.headers),
+      headers: combineHeaders7((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), options.headers),
       formData,
       failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler8(
+      successfulResponseHandler: createJsonResponseHandler7(
         xaiTranscriptionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -5750,7 +4878,7 @@ var XaiTranscriptionModel = class _XaiTranscriptionModel {
     var _a, _b, _c, _d, _e, _f, _g;
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
     const warnings = [];
-    const xaiOptions = await parseProviderOptions10({
+    const xaiOptions = await parseProviderOptions8({
       provider: "xai",
       providerOptions: options.providerOptions,
       schema: xaiTranscriptionModelOptionsSchema
@@ -5779,7 +4907,7 @@ var XaiTranscriptionModel = class _XaiTranscriptionModel {
       inputAudioFormat: options.inputAudioFormat,
       providerOptions: xaiOptions
     });
-    const headers = combineHeaders8((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), options.headers);
+    const headers = combineHeaders7((_f = (_e = this.config).headers) == null ? void 0 : _f.call(_e), options.headers);
     return {
       request: { body: url.toString() },
       response: {
@@ -5880,7 +5008,7 @@ function createXaiStreamingTranscriptionStream({
         onProcessingError: finishWithError,
         onMessageText: async (text) => {
           var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-          const parsed = await safeParseJSON3({ text });
+          const parsed = await safeParseJSON2({ text });
           if (!parsed.success) return;
           const raw = parsed.value;
           if (includeRawChunks) {
@@ -6041,15 +5169,15 @@ function timingFromXaiEvent(event) {
     ...event.start != null && event.duration != null ? { endSecond: event.start + event.duration } : {}
   };
 }
-var xaiTranscriptionResponseSchema = z25.object({
-  text: z25.string(),
-  language: z25.string().nullish(),
-  duration: z25.number().nullish(),
-  words: z25.array(
-    z25.object({
-      text: z25.string(),
-      start: z25.number(),
-      end: z25.number()
+var xaiTranscriptionResponseSchema = z23.object({
+  text: z23.string(),
+  language: z23.string().nullish(),
+  duration: z23.number().nullish(),
+  words: z23.array(
+    z23.object({
+      text: z23.string(),
+      start: z23.number(),
+      end: z23.number()
     })
   ).nullish()
 });
@@ -6071,15 +5199,6 @@ function createXai(options = {}) {
     },
     `ai-sdk/xai/${VERSION}`
   );
-  const createChatLanguageModel = (modelId) => {
-    return new XaiChatLanguageModel(modelId, {
-      provider: "xai.chat",
-      baseURL,
-      headers: getHeaders,
-      generateId,
-      fetch: options.fetch
-    });
-  };
   const createResponsesLanguageModel = (modelId) => {
     return new XaiResponsesLanguageModel(modelId, {
       provider: "xai.responses",
@@ -6166,7 +5285,6 @@ function createXai(options = {}) {
   const provider = (modelId) => createResponsesLanguageModel(modelId);
   provider.specificationVersion = "v4";
   provider.languageModel = createResponsesLanguageModel;
-  provider.chat = createChatLanguageModel;
   provider.responses = createResponsesLanguageModel;
   provider.embeddingModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });