@ai-sdk/xai 4.0.59 → 5.0.1

package/src/xai-chat-language-model.ts

@@ -1,778 +0,0 @@
-import {
-  APICallError,
-  type LanguageModelV4,
-  type LanguageModelV4CallOptions,
-  type LanguageModelV4Content,
-  type LanguageModelV4FinishReason,
-  type LanguageModelV4GenerateResult,
-  type LanguageModelV4StreamPart,
-  type LanguageModelV4StreamResult,
-  type LanguageModelV4Usage,
-  type SharedV4Warning,
-} from '@ai-sdk/provider';
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonResponseHandler,
-  extractResponseHeaders,
-  isCustomReasoning,
-  mapReasoningToProviderEffort,
-  parseProviderOptions,
-  postJsonToApi,
-  safeParseJSON,
-  serializeModelOptions,
-  WORKFLOW_SERIALIZE,
-  WORKFLOW_DESERIALIZE,
-  type FetchFunction,
-  type ParseResult,
-} from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-import { convertToXaiChatMessages } from './convert-to-xai-chat-messages';
-import { convertXaiChatUsage } from './convert-xai-chat-usage';
-import { getResponseMetadata } from './get-response-metadata';
-import { mapXaiFinishReason } from './map-xai-finish-reason';
-import { supportsReasoningEffort } from './supports-reasoning-effort';
-import {
-  xaiLanguageModelChatOptions,
-  type XaiChatModelId,
-} from './xai-chat-language-model-options';
-import { xaiFailedResponseHandler } from './xai-error';
-import { prepareTools } from './xai-prepare-tools';
-
-type XaiChatConfig = {
-  provider: string;
-  baseURL: string | undefined;
-  headers?: () => Record<string, string | undefined>;
-  generateId: () => string;
-  fetch?: FetchFunction;
-};
-
-export class XaiChatLanguageModel implements LanguageModelV4 {
-  readonly specificationVersion = 'v4';
-
-  readonly modelId: XaiChatModelId;
-
-  private readonly config: XaiChatConfig;
-
-  static [WORKFLOW_SERIALIZE](model: XaiChatLanguageModel) {
-    return serializeModelOptions({
-      modelId: model.modelId,
-      config: model.config,
-    });
-  }
-
-  static [WORKFLOW_DESERIALIZE](options: {
-    modelId: XaiChatModelId;
-    config: XaiChatConfig;
-  }) {
-    return new XaiChatLanguageModel(options.modelId, options.config);
-  }
-
-  constructor(modelId: XaiChatModelId, config: XaiChatConfig) {
-    this.modelId = modelId;
-    this.config = config;
-  }
-
-  get provider(): string {
-    return this.config.provider;
-  }
-
-  readonly supportedUrls: Record<string, RegExp[]> = {
-    'image/*': [/^https?:\/\/.*$/],
-  };
-
-  private async getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    topK,
-    frequencyPenalty,
-    presencePenalty,
-    stopSequences,
-    seed,
-    reasoning,
-    responseFormat,
-    providerOptions,
-    tools,
-    toolChoice,
-  }: LanguageModelV4CallOptions) {
-    const warnings: SharedV4Warning[] = [];
-
-    // parse xai-specific provider options
-    const options =
-      (await parseProviderOptions({
-        provider: 'xai',
-        providerOptions,
-        schema: xaiLanguageModelChatOptions,
-      })) ?? {};
-
-    // check for unsupported parameters
-    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' });
-    }
-
-    // convert ai sdk messages to xai format
-    const { messages, warnings: messageWarnings } =
-      await convertToXaiChatMessages(prompt);
-    warnings.push(...messageWarnings);
-
-    // prepare tools for xai
-    const {
-      tools: xaiTools,
-      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
-          : undefined,
-      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?.type === 'json'
-          ? responseFormat.schema != null
-            ? {
-                type: 'json_schema',
-                json_schema: {
-                  name: responseFormat.name ?? 'response',
-                  schema: responseFormat.schema,
-                  strict: true,
-                },
-              }
-            : { type: 'json_object' }
-          : undefined,
-
-      // 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: options.searchParameters.sources?.map(source => ({
-              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: source.includedXHandles ?? 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,
-              }),
-            })),
-          }
-        : undefined,
-
-      // messages in xai format
-      messages,
-
-      // tools in xai format
-      tools: xaiTools,
-      tool_choice: xaiToolChoice,
-    };
-
-    return {
-      args: baseArgs,
-      warnings,
-    };
-  }
-
-  async doGenerate(
-    options: LanguageModelV4CallOptions,
-  ): Promise<LanguageModelV4GenerateResult> {
-    const { args: body, warnings } = await this.getArgs(options);
-
-    const url = `${this.config.baseURL ?? 'https://api.x.ai/v1'}/chat/completions`;
-
-    const {
-      responseHeaders,
-      value: response,
-      rawValue: rawResponse,
-    } = await postJsonToApi({
-      url,
-      headers: combineHeaders(this.config.headers?.(), 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: Array<LanguageModelV4Content> = [];
-
-    // extract text content
-    if (choice.message.content != null && choice.message.content.length > 0) {
-      let text = choice.message.content;
-
-      // skip if this content duplicates the last assistant message
-      const lastMessage = body.messages[body.messages.length - 1];
-      if (lastMessage?.role === 'assistant' && text === lastMessage.content) {
-        text = '';
-      }
-
-      if (text.length > 0) {
-        content.push({ type: 'text', text });
-      }
-    }
-
-    // extract reasoning content
-    if (
-      choice.message.reasoning_content != null &&
-      choice.message.reasoning_content.length > 0
-    ) {
-      content.push({
-        type: 'reasoning',
-        text: choice.message.reasoning_content,
-      });
-    }
-
-    // extract tool calls
-    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,
-        });
-      }
-    }
-
-    // extract citations
-    if (response.citations != null) {
-      for (const url of response.citations) {
-        content.push({
-          type: 'source',
-          sourceType: 'url',
-          id: this.config.generateId(),
-          url,
-        });
-      }
-    }
-
-    return {
-      content,
-      finishReason: {
-        unified: mapXaiFinishReason(choice.finish_reason),
-        raw: choice.finish_reason ?? undefined,
-      },
-      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: LanguageModelV4CallOptions,
-  ): Promise<LanguageModelV4StreamResult> {
-    const { args, warnings } = await this.getArgs(options);
-    const body = {
-      ...args,
-      stream: true,
-      stream_options: {
-        include_usage: true,
-      },
-    };
-
-    const url = `${this.config.baseURL ?? 'https://api.x.ai/v1'}/chat/completions`;
-
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
-      body,
-      failedResponseHandler: xaiFailedResponseHandler,
-      successfulResponseHandler: async ({ response }) => {
-        const responseHeaders = extractResponseHeaders(response);
-        const contentType = response.headers.get('content-type');
-
-        if (contentType?.includes('application/json')) {
-          const responseBody = await response.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,
-              responseBody,
-              isRetryable:
-                parsedError.value.code ===
-                'The service is currently unavailable',
-            });
-          }
-
-          throw new APICallError({
-            message: 'Invalid JSON response',
-            url,
-            requestBodyValues: body,
-            statusCode: 200,
-            responseHeaders,
-            responseBody,
-          });
-        }
-
-        return createEventSourceResponseHandler(xaiChatChunkSchema)({
-          response,
-          url,
-          requestBodyValues: body,
-        });
-      },
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch,
-    });
-
-    let finishReason: LanguageModelV4FinishReason = {
-      unified: 'other',
-      raw: undefined,
-    };
-    let usage: LanguageModelV4Usage | undefined = undefined;
-    let serviceTier: string | undefined = undefined;
-    let isFirstChunk = true;
-    const contentBlocks: Record<
-      string,
-      { type: 'text' | 'reasoning'; ended: boolean }
-    > = {};
-    const lastReasoningDeltas: Record<string, string> = {};
-    let activeReasoningBlockId: string | undefined = undefined;
-
-    const self = this;
-
-    return {
-      stream: response.pipeThrough(
-        new TransformStream<
-          ParseResult<z.infer<typeof xaiChatChunkSchema>>,
-          LanguageModelV4StreamPart
-        >({
-          start(controller) {
-            controller.enqueue({ type: 'stream-start', warnings });
-          },
-
-          transform(chunk, controller) {
-            // Emit raw chunk if requested (before anything else)
-            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;
-
-            // emit response metadata on first chunk
-            if (isFirstChunk) {
-              controller.enqueue({
-                type: 'response-metadata',
-                ...getResponseMetadata(value),
-              });
-              isFirstChunk = false;
-            }
-
-            // emit citations if present (they come in the last chunk according to docs)
-            if (value.citations != null) {
-              for (const url of value.citations) {
-                controller.enqueue({
-                  type: 'source',
-                  sourceType: 'url',
-                  id: self.config.generateId(),
-                  url,
-                });
-              }
-            }
-
-            // update usage if present
-            if (value.usage != null) {
-              usage = convertXaiChatUsage(value.usage);
-            }
-
-            // the applied tier is repeated on every chunk; keep the latest
-            if (value.service_tier != null) {
-              serviceTier = value.service_tier;
-            }
-
-            const choice = value.choices[0];
-
-            // update finish reason if present
-            if (choice?.finish_reason != null) {
-              finishReason = {
-                unified: mapXaiFinishReason(choice.finish_reason),
-                raw: choice.finish_reason,
-              };
-            }
-
-            // exit if no delta to process
-            if (choice?.delta == null) {
-              return;
-            }
-
-            const delta = choice.delta;
-            const choiceIndex = choice.index;
-
-            // process text content
-            if (delta.content != null && delta.content.length > 0) {
-              const textContent = delta.content;
-
-              // end active reasoning block when text content arrives
-              if (
-                activeReasoningBlockId != null &&
-                !contentBlocks[activeReasoningBlockId].ended
-              ) {
-                controller.enqueue({
-                  type: 'reasoning-end',
-                  id: activeReasoningBlockId,
-                });
-                contentBlocks[activeReasoningBlockId].ended = true;
-                activeReasoningBlockId = undefined;
-              }
-
-              // skip if this content duplicates the last assistant message
-              const lastMessage = body.messages[body.messages.length - 1];
-              if (
-                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,
-              });
-            }
-
-            // process reasoning content
-            if (
-              delta.reasoning_content != null &&
-              delta.reasoning_content.length > 0
-            ) {
-              const blockId = `reasoning-${value.id || choiceIndex}`;
-
-              // skip if this reasoning content duplicates the last delta
-              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,
-              });
-            }
-
-            // process tool calls
-            if (delta.tool_calls != null && delta.tool_calls.length > 0) {
-              // end active reasoning block before tool calls start
-              if (
-                activeReasoningBlockId != null &&
-                !contentBlocks[activeReasoningBlockId].ended
-              ) {
-                controller.enqueue({
-                  type: 'reasoning-end',
-                  id: activeReasoningBlockId,
-                });
-                contentBlocks[activeReasoningBlockId].ended = true;
-                activeReasoningBlockId = undefined;
-              }
-
-              for (const toolCall of delta.tool_calls) {
-                // xai tool calls come in one piece (like mistral)
-                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) {
-            // end any blocks that haven't been ended yet
-            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 ?? {
-                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 },
-    };
-  }
-}
-
-// XAI API Response Schemas
-const xaiUsageSchema = z
-  .object({
-    prompt_tokens: z.number(),
-    completion_tokens: z.number(),
-    total_tokens: z.number(),
-    cost_in_usd_ticks: z.number().nullish(),
-    prompt_tokens_details: z
-      .object({
-        text_tokens: z.number().nullish(),
-        audio_tokens: z.number().nullish(),
-        image_tokens: z.number().nullish(),
-        cached_tokens: z.number().nullish(),
-      })
-      .catchall(z.json())
-      .nullish(),
-    completion_tokens_details: z
-      .object({
-        reasoning_tokens: z.number().nullish(),
-        audio_tokens: z.number().nullish(),
-        accepted_prediction_tokens: z.number().nullish(),
-        rejected_prediction_tokens: z.number().nullish(),
-      })
-      .catchall(z.json())
-      .nullish(),
-  })
-  .catchall(z.json());
-
-export type XaiChatUsage = z.infer<typeof xaiUsageSchema>;
-
-export const xaiChatResponseSchema = z.object({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z
-    .array(
-      z.object({
-        message: z.object({
-          role: z.enum(['assistant', 'tool']),
-          content: z.string().nullish(),
-          reasoning_content: z.string().nullish(),
-          tool_calls: z
-            .array(
-              z.object({
-                id: z.string(),
-                type: z.literal('function'),
-                function: z.object({
-                  name: z.string(),
-                  arguments: z.string(),
-                }),
-              }),
-            )
-            .nullish(),
-        }),
-        index: z.number(),
-        finish_reason: z.string().nullish(),
-      }),
-    )
-    .nullish(),
-  object: z.literal('chat.completion').nullish(),
-  usage: xaiUsageSchema.nullish(),
-  citations: z.array(z.string().url()).nullish(),
-  service_tier: z.string().nullish(),
-  code: z.string().nullish(),
-  error: z.string().nullish(),
-});
-
-export type XaiChatResponse = z.infer<typeof xaiChatResponseSchema>;
-
-const xaiChatChunkSchema = z.object({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
-    z.object({
-      delta: z.object({
-        role: z.enum(['assistant']).optional(),
-        content: z.string().nullish(),
-        reasoning_content: z.string().nullish(),
-        tool_calls: z
-          .array(
-            z.object({
-              id: z.string(),
-              type: z.literal('function'),
-              function: z.object({
-                name: z.string(),
-                arguments: z.string(),
-              }),
-            }),
-          )
-          .nullish(),
-      }),
-      finish_reason: z.string().nullish(),
-      index: z.number(),
-    }),
-  ),
-  usage: xaiUsageSchema.nullish(),
-  citations: z.array(z.string().url()).nullish(),
-  service_tier: z.string().nullish(),
-});
-
-const xaiStreamErrorSchema = z.object({
-  code: z.string(),
-  error: z.string(),
-});