converse-mcp-server 2.29.2 → 3.0.1

package/src/providers/xai.js

@@ -1,93 +1,45 @@
 /**
  * XAI (Grok) Provider
  *
- * Provider implementation for XAI Grok models using OpenAI-compatible API with custom baseURL.
+ * Provider implementation for XAI Grok models using the xAI Responses API
+ * (`POST /v1/responses`) via the `openai` SDK pointed at `https://api.x.ai/v1`.
+ * The legacy Chat Completions endpoint is deprecated for xAI: it returns no
+ * reasoning content and only "function calling" for tools, so grok-4.5's
+ * headline capabilities (reasoning content, native web/X search via Agent
+ * Tools) are only available through the Responses API.
+ *
  * Implements the unified interface: async invoke(messages, options) => { content, stop_reason, rawResponse }
+ * (or an AsyncGenerator of start/delta/thinking/usage/end/error events when stream=true).
  */
 
 import OpenAI from 'openai';
 import { debugLog, debugError } from '../utils/console.js';
 
-// Define supported Grok models with their capabilities
+// Curated catalog: grok-4.5 only (verified live 2026-07-11 against
+// GET https://api.x.ai/v1/models/grok-4.5 — id, aliases, 500k context).
+//
+// NOTE ON RETIRED IDS: xAI does NOT return a retirement error for old grok
+// identifiers. Direct lookups on retired IDs return HTTP 200 but are silently
+// server-remapped upstream (e.g. grok-4-0709 / grok-4-fast-* → grok-4.3,
+// grok-code-fast-1 → grok-build-0.1). This contradicts the general
+// "surface a clear retirement error" assumption for other providers. Explicit
+// retired IDs are passed through unchanged (resolveModelName passthrough) and
+// the xAI API remaps them itself — Converse never remaps client-side.
 const SUPPORTED_MODELS = {
-  'grok-4-0709': {
-    modelName: 'grok-4-0709',
-    friendlyName: 'X.AI (Grok 4)',
-    contextWindow: 256000,
-    maxOutputTokens: 256000,
-    supportsStreaming: true,
-    supportsImages: true,
-    supportsTemperature: true,
-    supportsWebSearch: true,
-    timeout: 300000, // 5 minutes
-    description:
-      'GROK-4 (256K context) - Latest advanced model from X.AI with image support and live search',
-    aliases: [
-      'grok',
-      'grok4',
-      'grok-4',
-      'grok-4-latest',
-      'grok 4',
-      'grok 4 latest',
-    ],
-  },
-  'grok-4-fast-reasoning': {
-    modelName: 'grok-4-fast-reasoning',
-    friendlyName: 'X.AI (Grok 4 Fast Reasoning)',
-    contextWindow: 2000000, // 2M tokens
-    maxOutputTokens: 2000000,
+  'grok-4.5': {
+    modelName: 'grok-4.5',
+    friendlyName: 'X.AI (Grok 4.5)',
+    contextWindow: 500000,
+    // No documented output ceiling — reuse the context window as the cap.
+    maxOutputTokens: 500000,
     supportsStreaming: true,
     supportsImages: true,
-    supportsTemperature: true,
     supportsWebSearch: true,
     supportsReasoning: true,
-    supportsFunctionCalling: true,
-    supportsStructuredOutputs: true,
-    timeout: 300000, // 5 minutes
-    description:
-      'GROK-4 Fast Reasoning (2M context) - Cost-efficient reasoning model with function calling and structured outputs',
-    aliases: [
-      'grok-4-fast',
-      'grok-4-fast-reasoning-latest',
-      'grok 4 fast',
-      'grok 4 fast reasoning',
-    ],
-  },
-  'grok-4-fast-non-reasoning': {
-    modelName: 'grok-4-fast-non-reasoning',
-    friendlyName: 'X.AI (Grok 4 Fast Non-Reasoning)',
-    contextWindow: 2000000, // 2M tokens
-    maxOutputTokens: 2000000,
-    supportsStreaming: true,
-    supportsImages: true,
-    supportsTemperature: true,
-    supportsWebSearch: true,
-    supportsReasoning: false,
-    supportsFunctionCalling: true,
-    supportsStructuredOutputs: true,
-    timeout: 300000, // 5 minutes
-    description:
-      'GROK-4 Fast Non-Reasoning (2M context) - Fast, cost-efficient model without reasoning for quick responses',
-    aliases: ['grok-4-fast-non-reasoning-latest', 'grok 4 fast non-reasoning'],
-  },
-  'grok-code-fast-1': {
-    modelName: 'grok-code-fast-1',
-    friendlyName: 'X.AI (Grok Code Fast 1)',
-    contextWindow: 256000,
-    maxOutputTokens: 256000,
-    supportsStreaming: true,
-    supportsImages: false,
-    supportsTemperature: true,
-    supportsWebSearch: false,
     timeout: 300000, // 5 minutes
     description:
-      'GROK Code Fast 1 (256K context) - Speedy and economical reasoning model that excels at agentic coding',
-    aliases: [
-      'grok-code-fast',
-      'grok-code-fast-1-0825',
-      'grok code fast',
-      'grok code fast 1',
-    ],
+      'Grok 4.5 (500K context) - Flagship X.AI model with image input, reasoning content, and native web/X search via Agent Tools',
+    aliases: ['grok', 'grok-4.5', 'grok-4.5-latest', 'grok-build-latest'],
   },
 };
 
@@ -127,10 +79,35 @@ function resolveModelName(modelName) {
     }
   }
 
-  // Return as-is if not found (let XAI API handle unknown models)
+  // Return as-is if not found (let XAI API handle unknown models — retired
+  // grok IDs are silently server-remapped upstream, see SUPPORTED_MODELS note).
   return modelName;
 }
 
+/**
+ * Map Converse reasoning_effort to a value grok-4.5 accepts.
+ *
+ * grok-4.5 supports ONLY low/medium/high (default high) and cannot disable
+ * reasoning — there is no `none`/off value. Sending an unsupported value
+ * (e.g. `none`/`minimal`/`max`) returns HTTP 400, so unsupported Converse
+ * levels are clamped into {low, medium, high} rather than forwarded.
+ */
+function resolveReasoningEffort(reasoningEffort) {
+  switch (reasoningEffort) {
+  case 'none':
+  case 'minimal':
+  case 'low':
+    return 'low';
+  case 'medium':
+    return 'medium';
+  case 'high':
+  case 'max':
+    return 'high';
+  default:
+    return 'high';
+  }
+}
+
 /**
  * Validate XAI API key format
  */
@@ -144,7 +121,7 @@ function validateApiKey(apiKey) {
 }
 
 /**
- * Convert messages to XAI/OpenAI format
+ * Convert messages to xAI Responses API format (input_text / input_image).
  */
 function convertMessages(messages) {
   if (!Array.isArray(messages)) {
@@ -182,17 +159,14 @@ function convertMessages(messages) {
       for (const item of content) {
         if (item.type === 'text') {
           convertedContent.push({
-            type: 'text',
+            type: 'input_text',
             text: item.text,
           });
         } else if (item.type === 'image' && item.source) {
-          // Convert Anthropic/Claude format to OpenAI format for XAI
+          // Convert Anthropic/Claude format to xAI Responses API format
           convertedContent.push({
-            type: 'image_url',
-            image_url: {
-              url: `data:${item.source.media_type};base64,${item.source.data}`,
-              detail: 'high',
-            },
+            type: 'input_image',
+            image_url: `data:${item.source.media_type};base64,${item.source.data}`,
           });
           debugLog(
             `[XAI] Converting image: ${item.source.media_type}, data length: ${item.source.data.length}`,
@@ -208,6 +182,44 @@ function convertMessages(messages) {
   });
 }
 
+/**
+ * Extract url citations from a Responses API output (web/X search results).
+ * Walks message output_text annotations for `url_citation` entries.
+ */
+function extractCitations(response) {
+  if (!response?.output || !Array.isArray(response.output)) {
+    return null;
+  }
+
+  const citations = [];
+  for (const item of response.output) {
+    if (item.type !== 'message' || !Array.isArray(item.content)) {
+      continue;
+    }
+    for (const part of item.content) {
+      if (!Array.isArray(part.annotations)) {
+        continue;
+      }
+      for (const annotation of part.annotations) {
+        if (annotation.type === 'url_citation') {
+          citations.push({
+            url: annotation.url,
+            title: annotation.title,
+            ...(annotation.start_index != null && {
+              start_index: annotation.start_index,
+            }),
+            ...(annotation.end_index != null && {
+              end_index: annotation.end_index,
+            }),
+          });
+        }
+      }
+    }
+  }
+
+  return citations.length > 0 ? citations : null;
+}
+
 /**
  * Main XAI provider implementation
  */
@@ -220,17 +232,16 @@ export const xaiProvider = {
    */
   async invoke(messages, options = {}) {
     const {
-      model = 'grok-4-0709',
-      temperature = 0.7,
+      model = 'grok-4.5',
       maxTokens = null,
       stream = false,
       reasoning_effort = 'medium',
-      use_websearch = false,
       signal,
       config,
       // Filter out options not meant for the API
       continuation_id, // eslint-disable-line no-unused-vars
       continuationStore, // eslint-disable-line no-unused-vars
+      web_search, // eslint-disable-line no-unused-vars -- xAI gates search on modelConfig, not this flag
       ...otherOptions
     } = options;
 
@@ -252,7 +263,7 @@ export const xaiProvider = {
     // Get base URL from config or use default
     const baseURL = config.providers?.xaiBaseUrl || 'https://api.x.ai/v1';
 
-    // Initialize OpenAI client with XAI base URL
+    // Initialize OpenAI client with XAI base URL (drives the Responses API)
     const openai = new OpenAI({
       apiKey: config.apiKeys.xai,
       baseURL,
@@ -262,44 +273,40 @@ export const xaiProvider = {
     const resolvedModel = resolveModelName(model);
     const modelConfig = SUPPORTED_MODELS[resolvedModel] || {};
 
-    // Convert and validate messages
-    const xaiMessages = convertMessages(messages);
+    // Convert and validate messages to Responses API input format
+    const xaiInput = convertMessages(messages);
 
-    // Filter out unsupported parameters for XAI/Grok models
-    const { reasoning_effort: _unused_reasoning_effort, ...supportedOptions } =
-      otherOptions;
-
-    // Build request payload
+    // Build Responses API request payload
     const requestPayload = {
       model: resolvedModel,
-      messages: xaiMessages,
+      input: xaiInput,
       stream,
-      ...supportedOptions,
+      ...otherOptions,
     };
 
-    // Add temperature (all Grok models support temperature)
-    if (temperature !== undefined) {
-      requestPayload.temperature = Math.max(0, Math.min(2, temperature));
-    }
-
-    // Add max tokens if specified
-    if (maxTokens) {
-      requestPayload.max_tokens = Math.min(
-        maxTokens,
-        modelConfig.maxOutputTokens || 256000,
-      );
+    // Web search via Agent Tools — attached whenever the model supports it
+    // (always-on capability gate, no per-request arg). The model decides
+    // per-request whether to actually search.
+    if (modelConfig.supportsWebSearch) {
+      requestPayload.tools = [{ type: 'web_search' }];
     }
 
-    // Add web search parameters if requested and model supports it
-    if (use_websearch && modelConfig.supportsWebSearch) {
-      requestPayload.search_parameters = {
-        mode: 'auto', // Let the model decide when to use web search
+    // Reasoning effort — capability-gated. Only attached when the resolved
+    // model supports reasoning, so unknown/retired pass-through IDs (which
+    // would HTTP-400 on grok-4.5 reasoning params) receive no reasoning field.
+    if (modelConfig.supportsReasoning && reasoning_effort) {
+      requestPayload.reasoning = {
+        effort: resolveReasoningEffort(reasoning_effort),
+        summary: 'auto',
       };
     }
 
-    // Add usage reporting for streaming mode
-    if (stream) {
-      requestPayload.stream_options = { include_usage: true };
+    // Add max output tokens if specified
+    if (maxTokens) {
+      requestPayload.max_output_tokens = Math.min(
+        maxTokens,
+        modelConfig.maxOutputTokens || 500000,
+      );
     }
 
     // If streaming is requested and model doesn't support it, fall back to non-streaming
@@ -317,17 +324,13 @@ export const xaiProvider = {
         requestPayload,
         resolvedModel,
         modelConfig,
-        use_websearch,
         signal,
       );
     }
 
-    // Note: XAI/Grok models don't currently support reasoning_effort parameter
-    // We silently ignore it for API consistency (no need to log warnings in tests)
-
     try {
       debugLog(
-        `[XAI] Calling ${resolvedModel} with ${xaiMessages.length} messages${use_websearch && modelConfig.supportsWebSearch ? ' (with live search)' : ''}`,
+        `[XAI] Calling ${resolvedModel} via Responses API with ${xaiInput.length} messages${modelConfig.supportsWebSearch ? ' (with web search)' : ''}`,
       );
 
       // Check if already aborted before making request
@@ -338,112 +341,103 @@ export const xaiProvider = {
       const startTime = Date.now();
 
       // Make the API call with abort signal support
-      const requestWithSignal = { ...requestPayload };
-      if (signal) {
-        requestWithSignal.signal = signal;
-      }
-      const response = await openai.chat.completions.create(requestWithSignal);
+      const requestOptions = signal ? { signal } : {};
+      const response = await openai.responses.create(
+        requestPayload,
+        requestOptions,
+      );
 
       const responseTime = Date.now() - startTime;
       debugLog(`[XAI] Response received in ${responseTime}ms`);
 
-      // Extract response data
-      const choice = response.choices[0];
-      if (!choice) {
-        throw new XAIProviderError(
-          'No response choice received from XAI',
-          'NO_RESPONSE_CHOICE',
+      // Extract content + reasoning from the Responses API output items
+      let content;
+      let reasoningSummary = null;
+
+      if (response.output && Array.isArray(response.output)) {
+        const messageOutput = response.output.find(
+          (item) => item.type === 'message',
+        );
+        const reasoningOutput = response.output.find(
+          (item) => item.type === 'reasoning',
         );
-      }
 
-      const content = choice.message?.content;
-      if (!content) {
+        if (!messageOutput || !messageOutput.content) {
+          throw new XAIProviderError(
+            'No message content in Responses API response',
+            'NO_RESPONSE_CONTENT',
+          );
+        }
+
+        const textContent = messageOutput.content.find(
+          (item) => item.type === 'output_text',
+        );
+        if (!textContent) {
+          throw new XAIProviderError(
+            'No text content in message output',
+            'NO_RESPONSE_CONTENT',
+          );
+        }
+        content = textContent.text;
+
+        // Extract reasoning summary if present (grok-4.5 returns encrypted
+        // reasoning content — only the summary is rendered).
+        if (reasoningOutput && Array.isArray(reasoningOutput.summary)) {
+          const summaryText = reasoningOutput.summary.find(
+            (item) => item.type === 'summary_text',
+          );
+          if (summaryText) {
+            reasoningSummary = summaryText.text;
+          }
+        }
+      } else if (response.output_text) {
+        // Legacy/simple format
+        content = response.output_text;
+      } else {
         throw new XAIProviderError(
-          'No content in response from XAI',
+          'No output in Responses API response',
           'NO_RESPONSE_CONTENT',
         );
       }
 
-      // Extract usage information
+      const stopReason = response.status || 'stop';
       const usage = response.usage || {};
+      const citations = extractCitations(response);
 
       // Return unified response format
       return {
         content,
-        stop_reason: choice.finish_reason || 'stop',
+        stop_reason: stopReason,
         rawResponse: response,
         metadata: {
           model: response.model || resolvedModel,
           usage: {
-            input_tokens: usage.prompt_tokens || 0,
-            output_tokens: usage.completion_tokens || 0,
+            input_tokens: usage.input_tokens || usage.prompt_tokens || 0,
+            output_tokens: usage.output_tokens || usage.completion_tokens || 0,
             total_tokens: usage.total_tokens || 0,
           },
           response_time_ms: responseTime,
-          finish_reason: choice.finish_reason,
+          finish_reason: stopReason,
           provider: 'xai',
-          web_search_used: use_websearch && modelConfig.supportsWebSearch,
+          web_search_used: !!modelConfig.supportsWebSearch,
+          ...(reasoningSummary && { reasoning: reasoningSummary }),
+          ...(citations && { citations }),
         },
       };
     } catch (error) {
       debugError('[XAI] Error during API call:', error);
-
-      // Handle specific XAI/OpenAI compatible errors
-      if (error.code === 'insufficient_quota') {
-        throw new XAIProviderError(
-          'XAI API quota exceeded',
-          'QUOTA_EXCEEDED',
-          error,
-        );
-      } else if (error.code === 'invalid_api_key') {
-        throw new XAIProviderError(
-          'Invalid XAI API key',
-          'INVALID_API_KEY',
-          error,
-        );
-      } else if (error.code === 'model_not_found') {
-        throw new XAIProviderError(
-          `Model ${resolvedModel} not found`,
-          'MODEL_NOT_FOUND',
-          error,
-        );
-      } else if (error.code === 'context_length_exceeded') {
-        throw new XAIProviderError(
-          'Context length exceeded for model',
-          'CONTEXT_LENGTH_EXCEEDED',
-          error,
-        );
-      } else if (error.type === 'invalid_request_error') {
-        throw new XAIProviderError(
-          `Invalid request: ${error.message}`,
-          'INVALID_REQUEST',
-          error,
-        );
-      } else if (error.type === 'rate_limit_error') {
-        throw new XAIProviderError(
-          'XAI rate limit exceeded',
-          'RATE_LIMIT_EXCEEDED',
-          error,
-        );
-      }
-
-      // Generic error handling
-      throw new XAIProviderError(
-        `XAI API error: ${error.message || 'Unknown error'}`,
-        'API_ERROR',
-        error,
-      );
+      throw this._normalizeError(error, resolvedModel);
     }
   },
 
   /**
-   * Create streaming generator for XAI responses
+   * Create streaming generator for XAI Responses API responses
    * @private
    * @param {OpenAI} openai - OpenAI client instance configured for XAI
    * @param {Object} requestPayload - Request payload
    * @param {string} resolvedModel - Resolved model name
    * @param {Object} modelConfig - Model configuration
-   * @param {boolean} use_websearch - Whether web search is enabled
+   * @param {AbortSignal} signal - Abort signal
    * @returns {AsyncGenerator} - Streaming generator yielding events
    */
   async *_createStreamingGenerator(
@@ -451,25 +445,22 @@ export const xaiProvider = {
     requestPayload,
     resolvedModel,
     modelConfig,
-    use_websearch,
     signal,
   ) {
-    const searchInfo =
-      use_websearch && modelConfig.supportsWebSearch
-        ? ' (with live search)'
-        : '';
+    const searchInfo = modelConfig.supportsWebSearch ? ' (with web search)' : '';
 
     debugLog(
-      `[XAI] Starting streaming for ${resolvedModel} with ${requestPayload.messages?.length} messages${searchInfo}`,
+      `[XAI] Starting streaming for ${resolvedModel} via Responses API with ${requestPayload.input?.length} messages${searchInfo}`,
     );
 
     const startTime = Date.now();
     let totalContent = '';
+    let totalReasoning = '';
+    let reasoningStreamed = false;
     let lastUsage = null;
     let finishReason = null;
     let finalModel = resolvedModel;
     let citations = null;
-    let searchSourcesUsed = 0;
 
     try {
       // Check if already aborted before starting
@@ -485,12 +476,12 @@ export const xaiProvider = {
         provider: 'xai',
       };
 
-      // Create stream using OpenAI SDK with XAI base URL and abort signal support
-      const requestWithSignal = { ...requestPayload };
-      if (signal) {
-        requestWithSignal.signal = signal;
-      }
-      const stream = await openai.chat.completions.create(requestWithSignal);
+      // Create stream using the Responses API with abort signal support
+      const requestOptions = signal ? { signal } : {};
+      const stream = await openai.responses.create(
+        requestPayload,
+        requestOptions,
+      );
 
       // Process stream chunks
       for await (const chunk of stream) {
@@ -502,10 +493,10 @@ export const xaiProvider = {
             );
             break;
           }
-          // Handle Chat Completions API streaming format (XAI uses OpenAI-compatible format)
-          const choice = chunk.choices?.[0];
-          if (choice) {
-            const content = choice.delta?.content || '';
+
+          // Answer-text deltas
+          if (chunk.type === 'response.output_text.delta') {
+            const content = chunk.delta || '';
             if (content) {
               totalContent += content;
               yield {
@@ -514,29 +505,49 @@ export const xaiProvider = {
                 timestamp: new Date().toISOString(),
               };
             }
-
-            if (choice.finish_reason) {
-              finishReason = choice.finish_reason;
+          } else if (
+            chunk.type === 'response.reasoning_summary_text.delta'
+          ) {
+            // Reasoning summary streamed incrementally — emit as thinking
+            // deltas so the normalizer accumulates them separately from text.
+            const summaryDelta = chunk.delta || '';
+            if (summaryDelta) {
+              totalReasoning += summaryDelta;
+              reasoningStreamed = true;
+              yield {
+                type: 'thinking',
+                content: summaryDelta,
+                timestamp: new Date().toISOString(),
+              };
             }
-          }
-
-          // Handle usage information (typically in final chunk)
-          if (chunk.usage) {
-            lastUsage = chunk.usage;
-            // Track search sources used for live search cost monitoring
-            if (chunk.usage.num_sources_used) {
-              searchSourcesUsed = chunk.usage.num_sources_used;
+          } else if (
+            chunk.type === 'response.reasoning_summary_part.done' ||
+            chunk.type === 'response.reasoning_summary_text.done'
+          ) {
+            // Some responses deliver the summary only as a terminal "done"
+            // event (no deltas). Emit a single thinking event in that case;
+            // if deltas already streamed, skip to avoid double-counting.
+            if (!reasoningStreamed) {
+              const summaryText = chunk.part?.text || chunk.text || '';
+              if (summaryText) {
+                totalReasoning = summaryText;
+                yield {
+                  type: 'thinking',
+                  content: summaryText,
+                  timestamp: new Date().toISOString(),
+                };
+              }
+            }
+          } else if (chunk.type === 'response.completed') {
+            finishReason = chunk.response?.status || 'stop';
+            finalModel = chunk.response?.model || resolvedModel;
+            if (chunk.response?.usage) {
+              lastUsage = chunk.response.usage;
+            }
+            const chunkCitations = extractCitations(chunk.response);
+            if (chunkCitations) {
+              citations = chunkCitations;
             }
-          }
-
-          // Handle citations for live search (XAI-specific feature)
-          if (chunk.citations) {
-            citations = chunk.citations;
-          }
-
-          // Update model if provided
-          if (chunk.model) {
-            finalModel = chunk.model;
           }
         } catch (chunkError) {
           debugError('[XAI] Error processing stream chunk:', chunkError);
@@ -553,54 +564,38 @@ export const xaiProvider = {
       }
 
       const responseTime = Date.now() - startTime;
-      debugLog(
-        `[XAI] Streaming completed in ${responseTime}ms${searchSourcesUsed > 0 ? ` (used ${searchSourcesUsed} search sources)` : ''}`,
-      );
+      debugLog(`[XAI] Streaming completed in ${responseTime}ms`);
 
       // Yield usage information if available
       if (lastUsage) {
-        const usageEvent = {
+        yield {
           type: 'usage',
           usage: {
-            input_tokens: lastUsage.prompt_tokens || 0,
-            output_tokens: lastUsage.completion_tokens || 0,
+            input_tokens: lastUsage.input_tokens || lastUsage.prompt_tokens || 0,
+            output_tokens:
+              lastUsage.output_tokens || lastUsage.completion_tokens || 0,
             total_tokens: lastUsage.total_tokens || 0,
           },
           timestamp: new Date().toISOString(),
         };
-
-        // Add search-specific usage information
-        if (searchSourcesUsed > 0) {
-          usageEvent.usage.search_sources_used = searchSourcesUsed;
-          usageEvent.usage.search_cost_estimate = searchSourcesUsed * 0.025; // $0.025 per source
-        }
-
-        yield usageEvent;
       }
 
-      // Determine web search usage
-      const webSearchUsed = use_websearch && modelConfig.supportsWebSearch;
-
       // Build final metadata
       const metadata = {
         model: finalModel,
         usage: {
-          input_tokens: lastUsage?.prompt_tokens || 0,
-          output_tokens: lastUsage?.completion_tokens || 0,
+          input_tokens: lastUsage?.input_tokens || lastUsage?.prompt_tokens || 0,
+          output_tokens:
+            lastUsage?.output_tokens || lastUsage?.completion_tokens || 0,
           total_tokens: lastUsage?.total_tokens || 0,
         },
         response_time_ms: responseTime,
         finish_reason: finishReason || 'stop',
         provider: 'xai',
-        web_search_used: webSearchUsed,
+        web_search_used: !!modelConfig.supportsWebSearch,
+        ...(totalReasoning && { reasoning: totalReasoning }),
       };
 
-      // Add search-specific metadata
-      if (searchSourcesUsed > 0) {
-        metadata.search_sources_used = searchSourcesUsed;
-        metadata.search_cost_estimate = searchSourcesUsed * 0.025;
-      }
-
       if (citations) {
         metadata.citations = citations;
       }
@@ -616,38 +611,15 @@ export const xaiProvider = {
     } catch (error) {
       debugError('[XAI] Streaming error:', error);
 
-      // Handle specific XAI/OpenAI compatible errors in streaming context
-      let errorCode = 'STREAMING_ERROR';
-      let errorMessage = `XAI streaming error: ${error.message || 'Unknown error'}`;
-      let recoverable = false;
-
-      if (error.code === 'insufficient_quota') {
-        errorCode = 'QUOTA_EXCEEDED';
-        errorMessage = 'XAI API quota exceeded';
-      } else if (error.code === 'invalid_api_key') {
-        errorCode = 'INVALID_API_KEY';
-        errorMessage = 'Invalid XAI API key';
-      } else if (error.code === 'model_not_found') {
-        errorCode = 'MODEL_NOT_FOUND';
-        errorMessage = `Model ${resolvedModel} not found`;
-      } else if (error.code === 'context_length_exceeded') {
-        errorCode = 'CONTEXT_LENGTH_EXCEEDED';
-        errorMessage = 'Context length exceeded for model';
-      } else if (error.type === 'invalid_request_error') {
-        errorCode = 'INVALID_REQUEST';
-        errorMessage = `Invalid request: ${error.message}`;
-      } else if (error.type === 'rate_limit_error') {
-        errorCode = 'RATE_LIMIT_EXCEEDED';
-        errorMessage = 'XAI rate limit exceeded';
-        recoverable = true;
-      }
+      const normalized = this._normalizeError(error, resolvedModel);
+      const recoverable = normalized.code === 'RATE_LIMIT_EXCEEDED';
 
       // Yield final error event
       yield {
         type: 'error',
         error: {
-          message: errorMessage,
-          code: errorCode,
+          message: normalized.message,
+          code: normalized.code,
           recoverable,
           originalError: error.message,
         },
@@ -655,10 +627,56 @@ export const xaiProvider = {
       };
 
       // Re-throw to maintain error propagation
-      throw new XAIProviderError(errorMessage, errorCode, error);
+      throw normalized;
     }
   },
 
+  /**
+   * Normalize an SDK/API error into an XAIProviderError with a stable code.
+   * @private
+   */
+  _normalizeError(error, resolvedModel) {
+    if (error instanceof XAIProviderError) {
+      return error;
+    }
+
+    if (error.code === 'insufficient_quota') {
+      return new XAIProviderError('XAI API quota exceeded', 'QUOTA_EXCEEDED', error);
+    } else if (error.code === 'invalid_api_key') {
+      return new XAIProviderError('Invalid XAI API key', 'INVALID_API_KEY', error);
+    } else if (error.code === 'model_not_found') {
+      return new XAIProviderError(
+        `Model ${resolvedModel} not found`,
+        'MODEL_NOT_FOUND',
+        error,
+      );
+    } else if (error.code === 'context_length_exceeded') {
+      return new XAIProviderError(
+        'Context length exceeded for model',
+        'CONTEXT_LENGTH_EXCEEDED',
+        error,
+      );
+    } else if (error.type === 'invalid_request_error') {
+      return new XAIProviderError(
+        `Invalid request: ${error.message}`,
+        'INVALID_REQUEST',
+        error,
+      );
+    } else if (error.type === 'rate_limit_error') {
+      return new XAIProviderError(
+        'XAI rate limit exceeded',
+        'RATE_LIMIT_EXCEEDED',
+        error,
+      );
+    }
+
+    return new XAIProviderError(
+      `XAI API error: ${error.message || 'Unknown error'}`,
+      'API_ERROR',
+      error,
+    );
+  },
+
   /**
    * Validate configuration for XAI provider
    * @param {Object} config - Configuration object