@gullabs/xai 0.5.1 → 0.6.1

package/dist/index.cjs

@@ -33,6 +33,12 @@ async function buildXaiClient(auth) {
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isXaiMessageItem(item) {
+  return item.type === "message" && Array.isArray(item.content);
+}
+function isXaiReasoningItem(item) {
+  return item.type === "reasoning" && Array.isArray(item.summary);
+}
 function badXaiRequest(message) {
   return new core.LlmError(message, { kind: "bad_request", retryable: false });
 }
@@ -77,10 +83,16 @@ function mapPart(p) {
       }
       return { type: "input_file", file_id: p.fileId };
     }
+    case "tool-call":
+    case "tool-result":
+      throw badXaiRequest(
+        `xAI mapPart does not emit ${p.kind} as a content part; the request mapper handles replay items.`
+      );
     default:
       return core.assertNever(p);
   }
 }
+var XAI_PROVIDER_OPTION_KEYS = /* @__PURE__ */ new Set(["promptCacheKey", "tools", "parallelToolCalls"]);
 function mapXaiProviderOptions(xaiOpts, model) {
   if (xaiOpts === void 0) {
     return {};
@@ -88,12 +100,14 @@ function mapXaiProviderOptions(xaiOpts, model) {
   if (!isPlainRecord(xaiOpts)) {
     throw badXaiRequest(`providerOptions.xai must be an object for model "${model}".`);
   }
-  const unknownKeys = Object.keys(xaiOpts).filter((key) => key !== "promptCacheKey");
+  const unknownKeys = Object.keys(xaiOpts).filter(
+    (key) => !XAI_PROVIDER_OPTION_KEYS.has(key)
+  );
   if (unknownKeys.length > 0) {
     throw badXaiRequest(
       `providerOptions.xai contains unsupported keys [${unknownKeys.join(
         ", "
-      )}] for model "${model}". Allowed keys: promptCacheKey.`
+      )}] for model "${model}". Allowed keys: promptCacheKey, tools, parallelToolCalls.`
     );
   }
   const mapped = {};
@@ -105,8 +119,69 @@ function mapXaiProviderOptions(xaiOpts, model) {
     }
     mapped.promptCacheKey = xaiOpts["promptCacheKey"];
   }
+  if (xaiOpts["tools"] !== void 0) {
+    mapped.tools = mapXaiSearchTools(xaiOpts["tools"], model);
+  }
+  if (xaiOpts["parallelToolCalls"] !== void 0) {
+    if (typeof xaiOpts["parallelToolCalls"] !== "boolean") {
+      throw badXaiRequest(
+        `providerOptions.xai.parallelToolCalls must be a boolean for model "${model}".`
+      );
+    }
+    mapped.parallelToolCalls = xaiOpts["parallelToolCalls"];
+  }
   return mapped;
 }
+function mapXaiSearchTools(tools, model) {
+  if (!Array.isArray(tools)) {
+    throw badXaiRequest(
+      `providerOptions.xai.tools must be an array for model "${model}".`
+    );
+  }
+  return tools.map((tool, index) => {
+    if (!isPlainRecord(tool) || typeof tool["type"] !== "string") {
+      throw badXaiRequest(
+        `providerOptions.xai.tools[${index}] must be an object with a type for model "${model}".`
+      );
+    }
+    if (tool["type"] === "web_search") {
+      const wire = { type: "web_search" };
+      if (tool["allowedDomains"] !== void 0)
+        wire["allowed_domains"] = tool["allowedDomains"];
+      if (tool["excludedDomains"] !== void 0) {
+        wire["excluded_domains"] = tool["excludedDomains"];
+      }
+      if (tool["enableImageUnderstanding"] !== void 0) {
+        wire["enable_image_understanding"] = tool["enableImageUnderstanding"];
+      }
+      if (tool["enableImageSearch"] !== void 0) {
+        wire["enable_image_search"] = tool["enableImageSearch"];
+      }
+      return wire;
+    }
+    if (tool["type"] === "x_search") {
+      const wire = { type: "x_search" };
+      if (tool["allowedXHandles"] !== void 0) {
+        wire["allowed_x_handles"] = tool["allowedXHandles"];
+      }
+      if (tool["excludedXHandles"] !== void 0) {
+        wire["excluded_x_handles"] = tool["excludedXHandles"];
+      }
+      if (tool["fromDate"] !== void 0) wire["from_date"] = tool["fromDate"];
+      if (tool["toDate"] !== void 0) wire["to_date"] = tool["toDate"];
+      if (tool["enableImageUnderstanding"] !== void 0) {
+        wire["enable_image_understanding"] = tool["enableImageUnderstanding"];
+      }
+      if (tool["enableVideoUnderstanding"] !== void 0) {
+        wire["enable_video_understanding"] = tool["enableVideoUnderstanding"];
+      }
+      return wire;
+    }
+    throw badXaiRequest(
+      `providerOptions.xai.tools[${index}].type "${String(tool["type"])}" is not supported for model "${model}".`
+    );
+  });
+}
 function mapFinishReason(response) {
   if (response.status === "completed") {
     return "stop";
@@ -138,6 +213,14 @@ function mapUsage(usage) {
       details[key] = value;
     }
   }
+  const toolUsage = usage["server_side_tool_usage_details"];
+  if (isPlainRecord(toolUsage)) {
+    for (const [key, value] of Object.entries(toolUsage)) {
+      if (typeof value === "number") {
+        details[key] = value;
+      }
+    }
+  }
   const raw = usage;
   const result = {
     inputTokens,
@@ -256,10 +339,48 @@ function xaiAdapter(opts) {
       const warnings = [];
       const model = req.model;
       const genConfig = req.config;
-      const input = req.messages.map((msg) => ({
-        role: msg.role === "assistant" ? "assistant" : "user",
-        content: msg.parts.map(mapPart)
-      }));
+      const input = [];
+      for (const msg of req.messages) {
+        const contentParts = [];
+        for (const part of msg.parts) {
+          if (part.kind === "tool-call") {
+            if (contentParts.length > 0) {
+              input.push({
+                role: msg.role === "assistant" ? "assistant" : "user",
+                content: contentParts.splice(0)
+              });
+            }
+            input.push({
+              type: "function_call",
+              call_id: part.toolCallId,
+              name: part.toolName,
+              arguments: JSON.stringify(part.args)
+            });
+            continue;
+          }
+          if (part.kind === "tool-result") {
+            if (contentParts.length > 0) {
+              input.push({
+                role: msg.role === "assistant" ? "assistant" : "user",
+                content: contentParts.splice(0)
+              });
+            }
+            input.push({
+              type: "function_call_output",
+              call_id: part.toolCallId,
+              output: JSON.stringify(part.result)
+            });
+            continue;
+          }
+          contentParts.push(mapPart(part));
+        }
+        if (contentParts.length > 0) {
+          input.push({
+            role: msg.role === "assistant" ? "assistant" : "user",
+            content: contentParts
+          });
+        }
+      }
       const params = {
         model,
         input,
@@ -329,6 +450,38 @@ function xaiAdapter(opts) {
       if (xaiProviderConfig.promptCacheKey !== void 0) {
         params.prompt_cache_key = xaiProviderConfig.promptCacheKey;
       }
+      const hasFileRef = req.messages.some(
+        (msg) => msg.parts.some((part) => part.kind === "file-ref")
+      );
+      const searchTools = xaiProviderConfig.tools;
+      if (searchTools !== void 0) {
+        if (req.modelDescriptor?.capabilities?.grounding !== true) {
+          throw badXaiRequest(
+            `providerOptions.xai.tools requires capabilities.grounding on the model descriptor for "${model}".`
+          );
+        }
+        params.tools = searchTools;
+      }
+      if (req.tools !== void 0 && req.tools.length > 0) {
+        if (req.modelDescriptor?.capabilities?.functionCalling !== true) {
+          throw badXaiRequest(
+            `tools is not supported for xai model "${model}" (capabilities.functionCalling is not true).`
+          );
+        }
+        const functionTools = req.tools.map((tool) => ({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputJsonSchema
+        }));
+        params.tools = [...params.tools ?? [], ...functionTools];
+        if (req.toolChoice !== void 0) {
+          params.tool_choice = typeof req.toolChoice === "string" ? req.toolChoice : { type: "function", name: req.toolChoice.name };
+        }
+      }
+      if (xaiProviderConfig.parallelToolCalls !== void 0) {
+        params.parallel_tool_calls = xaiProviderConfig.parallelToolCalls;
+      }
       let response;
       try {
         const buildClient = opts?._clientFactory ?? buildXaiClient;
@@ -347,14 +500,29 @@ function xaiAdapter(opts) {
       let text = "";
       let reasoningText;
       const messageItems = [];
+      const toolCalls = [];
       for (const item of response.output) {
-        if (item.type === "message") {
+        if (isXaiMessageItem(item)) {
           messageItems.push(item);
-        } else {
+        } else if (isXaiReasoningItem(item)) {
           const joined = item.summary.map((s) => s.text).join("");
           if (joined.length > 0) {
             reasoningText = (reasoningText ?? "") + joined;
           }
+        } else if (item.type === "function_call") {
+          const callId = typeof item["call_id"] === "string" ? item["call_id"] : "";
+          const name = typeof item["name"] === "string" ? item["name"] : "";
+          let args = {};
+          if (typeof item["arguments"] === "string") {
+            try {
+              args = JSON.parse(item["arguments"]);
+            } catch {
+              args = item["arguments"];
+            }
+          }
+          if (callId.length > 0 && name.length > 0) {
+            toolCalls.push({ toolCallId: callId, toolName: name, args });
+          }
         }
       }
       if (messageItems.length > 0) {
@@ -376,6 +544,29 @@ function xaiAdapter(opts) {
       }
       const usage = mapUsage(response.usage);
       const finishReason = mapFinishReason(response);
+      const expectedToolCounters = expectedServerToolCounters(
+        xaiProviderConfig.tools);
+      if (expectedToolCounters.length > 0 || hasFileRef) {
+        usage.details["server_tools_requested"] = 1;
+        const missing = expectedToolCounters.filter((key) => !(key in usage.details));
+        if (missing.length > 0) {
+          usage.details["server_tools_missing"] = 1;
+          warnings.push({
+            type: "other",
+            message: `xai: server tools were requested but usage is missing counters [${missing.join(
+              ", "
+            )}]; tool cost will be estimated.`
+          });
+        }
+        if (hasFileRef) {
+          usage.details["attachment_search_unpinned"] = 1;
+          warnings.push({
+            type: "other",
+            message: "xai: file-ref enables attachment_search but that counter is not live-pinned; tool cost is estimated."
+          });
+        }
+      }
+      const citations = collectXaiCitations(response, messageItems);
       const providerMeta = {};
       const contextDetails = response.usage["context_details"];
       if (isPlainRecord(contextDetails)) {
@@ -395,12 +586,159 @@ function xaiAdapter(opts) {
         ...reasoningText !== void 0 ? { reasoningText } : {},
         ...rawStructured !== void 0 ? { rawStructured } : {},
         ...servedServiceTier !== void 0 ? { servedServiceTier } : {},
-        ...Object.keys(providerMeta).length > 0 ? { providerMetadata: providerMeta } : {}
+        ...Object.keys(providerMeta).length > 0 ? { providerMetadata: providerMeta } : {},
+        ...citations.length > 0 ? { citations } : {},
+        ...toolCalls.length > 0 ? { toolCalls, finishReason: "tool_calls" } : {}
       };
       return result;
+    },
+    async countTokens(req, ctx) {
+      if (req.provider !== "xai") {
+        throw new core.LlmError(
+          `xaiAdapter received a request for provider "${req.provider}", expected "xai".`,
+          { kind: "bad_request", retryable: false }
+        );
+      }
+      if (req.tools !== void 0 && req.tools.length > 0) {
+        throw badXaiRequest(
+          "xAI countTokens rejects tools; tokenize-text cannot represent tool declarations."
+        );
+      }
+      const text = concatenateTokenizeText(req);
+      const apiKey = requireApiKey(ctx.auth);
+      const fetchImpl = opts?._fetch ?? fetch;
+      try {
+        const res = await fetchImpl("https://api.x.ai/v1/tokenize-text", {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ model: req.model, text }),
+          ...ctx.signal !== void 0 ? { signal: ctx.signal } : {}
+        });
+        if (!res.ok) {
+          let parsed;
+          try {
+            parsed = await res.json();
+          } catch {
+            parsed = await res.text().catch(() => "");
+          }
+          throw Object.assign(new Error(`xAI tokenize-text HTTP ${res.status}`), {
+            status: res.status,
+            error: parsed
+          });
+        }
+        const raw = await res.json();
+        if (!isPlainRecord(raw) || !Array.isArray(raw["token_ids"])) {
+          throw new core.LlmError(
+            "xAI tokenize-text response is malformed: missing required field: token_ids",
+            { kind: "server", retryable: true, provider: "xai" }
+          );
+        }
+        const n = raw["token_ids"].length;
+        return {
+          totalTokens: n,
+          accuracy: "lower-bound",
+          details: { textTokens: n },
+          raw
+        };
+      } catch (rawErr) {
+        if (rawErr instanceof Error && rawErr.name === "AbortError") {
+          throw new core.LlmError("xAI tokenize-text aborted", {
+            kind: "aborted",
+            retryable: false,
+            provider: "xai",
+            cause: rawErr
+          });
+        }
+        throw classifyXaiError(rawErr);
+      }
     }
   };
 }
+var WEB_SEARCH_COUNTER = "web_search_calls";
+var X_SEARCH_COUNTER = "x_search_calls";
+function expectedServerToolCounters(tools, _hasFileRef) {
+  const keys = [];
+  if (tools !== void 0) {
+    for (const tool of tools) {
+      if (tool["type"] === "web_search") keys.push(WEB_SEARCH_COUNTER);
+      if (tool["type"] === "x_search") keys.push(X_SEARCH_COUNTER);
+    }
+  }
+  return keys;
+}
+function collectXaiCitations(response, messageItems) {
+  const seen = /* @__PURE__ */ new Set();
+  const citations = [];
+  const push = (url, title) => {
+    if (typeof url !== "string" || url.length === 0) return;
+    if (seen.has(url)) return;
+    seen.add(url);
+    const citation = { url };
+    if (typeof title === "string" && title.length > 0 && title !== url) {
+      citation.title = title;
+    }
+    try {
+      const parsed = new URL(url);
+      if (parsed.hostname.length > 0) {
+        citation.sourceName = parsed.hostname.startsWith("www.") ? parsed.hostname.slice(4) : parsed.hostname;
+      }
+    } catch {
+    }
+    citations.push(citation);
+  };
+  if (Array.isArray(response.citations)) {
+    for (const item of response.citations) {
+      if (typeof item === "string") {
+        push(item, void 0);
+      } else if (isPlainRecord(item)) {
+        push(item["url"] ?? item["uri"], item["title"]);
+      }
+    }
+  }
+  const lastMessage = messageItems.at(-1);
+  const citationMessages = lastMessage === void 0 ? [] : [lastMessage];
+  for (const item of citationMessages) {
+    for (const part of item.content) {
+      const annotations = part.annotations;
+      if (!Array.isArray(annotations)) continue;
+      for (const ann of annotations) {
+        if (!isPlainRecord(ann)) continue;
+        if (ann["type"] !== void 0 && ann["type"] !== "url_citation") continue;
+        push(ann["url"], ann["title"]);
+      }
+    }
+  }
+  return citations;
+}
+function concatenateTokenizeText(req) {
+  const chunks = [];
+  if (req.system !== void 0 && req.system.length > 0) {
+    chunks.push(req.system);
+  }
+  for (const message of req.messages) {
+    for (const part of message.parts) {
+      switch (part.kind) {
+        case "text":
+          chunks.push(part.text);
+          break;
+        case "inline-media":
+        case "file-uri":
+        case "file-ref":
+        case "tool-call":
+        case "tool-result":
+          throw badXaiRequest(
+            `xAI countTokens rejects ${part.kind} parts; tokenize-text is text-only.`
+          );
+        default:
+          return core.assertNever(part);
+      }
+    }
+  }
+  return chunks.join("\n");
+}
 var XAI_FILE_TTL_MIN_SECONDS = 3600;
 var XAI_FILE_TTL_MAX_SECONDS = 2592e3;
 var XAI_FILE_MAX_BYTES = 48 * 1024 * 1024;
@@ -856,6 +1194,100 @@ var XaiFileStore = class {
     return new Uint8Array(buf);
   }
 };
+var webSearchFlags = {
+  enableImageUnderstanding: zod.z.boolean().optional().meta({
+    title: "Enable Image Understanding",
+    description: "Ask xAI to analyze images found during web search."
+  }),
+  enableImageSearch: zod.z.boolean().optional().meta({
+    title: "Enable Image Search",
+    description: "Ask xAI to include image search results."
+  })
+};
+var XaiWebSearchToolSchema = zod.z.union([
+  zod.z.strictObject({
+    type: zod.z.literal("web_search"),
+    allowedDomains: zod.z.array(zod.z.string()).max(5),
+    ...webSearchFlags
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("web_search"),
+    excludedDomains: zod.z.array(zod.z.string()).max(5),
+    ...webSearchFlags
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("web_search"),
+    ...webSearchFlags
+  })
+]).meta({
+  title: "XaiWebSearchTool",
+  description: "xAI web_search server tool. allowedDomains and excludedDomains are mutually exclusive (max 5)."
+});
+var xSearchFlags = {
+  fromDate: zod.z.iso.date().optional().meta({
+    title: "From Date",
+    description: "Inclusive ISO-8601 date lower bound for X search."
+  }),
+  toDate: zod.z.iso.date().optional().meta({
+    title: "To Date",
+    description: "Inclusive ISO-8601 date upper bound for X search."
+  }),
+  enableImageUnderstanding: zod.z.boolean().optional().meta({
+    title: "Enable Image Understanding",
+    description: "Ask xAI to analyze images in matched posts."
+  }),
+  enableVideoUnderstanding: zod.z.boolean().optional().meta({
+    title: "Enable Video Understanding",
+    description: "Ask xAI to analyze videos in matched posts."
+  })
+};
+var XaiXSearchToolSchema = zod.z.union([
+  zod.z.strictObject({
+    type: zod.z.literal("x_search"),
+    allowedXHandles: zod.z.array(zod.z.string()).max(20),
+    ...xSearchFlags
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("x_search"),
+    excludedXHandles: zod.z.array(zod.z.string()).max(20),
+    ...xSearchFlags
+  }),
+  zod.z.strictObject({
+    type: zod.z.literal("x_search"),
+    ...xSearchFlags
+  })
+]).meta({
+  title: "XaiXSearchTool",
+  description: "xAI x_search server tool. allowedXHandles and excludedXHandles are mutually exclusive (max 20)."
+});
+var XaiToolsSchema = zod.z.union([
+  zod.z.tuple([XaiWebSearchToolSchema]),
+  zod.z.tuple([XaiXSearchToolSchema]),
+  zod.z.tuple([XaiWebSearchToolSchema, XaiXSearchToolSchema]),
+  zod.z.tuple([XaiXSearchToolSchema, XaiWebSearchToolSchema])
+]).meta({
+  title: "XaiTools",
+  description: "xAI Live Search tools. At most one web_search and at most one x_search."
+});
+var XaiProviderOptionsSchema = zod.z.strictObject({
+  promptCacheKey: zod.z.string().min(1).optional().meta({
+    title: "Prompt Cache Key",
+    description: "xAI conversation-routing cache key \u2014 maps to Responses API `prompt_cache_key`."
+  }),
+  tools: XaiToolsSchema.optional().meta({
+    title: "Live Search Tools",
+    description: "xAI server-side web_search / x_search tools."
+  }),
+  parallelToolCalls: zod.z.boolean().optional().meta({
+    title: "Parallel Tool Calls",
+    description: "xAI Responses parallel_tool_calls. Not a generic contract field."
+  })
+}).meta({
+  title: "xAI Provider Options",
+  description: "Allowlisted xAI provider options."
+});
+
+// src/model-config/grok-4-5.ts
 var Grok45ConfigSchema = zod.z.strictObject({
   temperature: zod.z.number().optional().meta({
     title: "Temperature",
@@ -870,9 +1302,9 @@ var Grok45ConfigSchema = zod.z.strictObject({
     description: "Maximum output token cap for grok-4.5. No artificial ceiling \u2014 xAI accepts arbitrarily large values (live-verified); truncation surfaces as finishReason:'length', not an error."
   }),
   reasoning: zod.z.strictObject({
-    effort: zod.z.enum(["low", "high"]).meta({
+    effort: zod.z.enum(["low", "medium", "high"]).meta({
       title: "Reasoning Effort",
-      description: 'Reasoning effort for grok-4.5. Only "low" and "high" are admitted (live-verified); "none"/"medium"/"xhigh" are rejected by the live API.'
+      description: 'Reasoning effort for grok-4.5. "low", "medium", and "high" are admitted (live-verified 2026-08-24); "none"/"xhigh" are rejected by the live API. Vendor default when omitted is "high".'
     })
   }).optional().meta({
     title: "Reasoning",
@@ -883,22 +1315,14 @@ var Grok45ConfigSchema = zod.z.strictObject({
     description: "Logical request timeout in milliseconds."
   }),
   providerOptions: zod.z.strictObject({
-    xai: zod.z.strictObject({
-      promptCacheKey: zod.z.string().min(1).optional().meta({
-        title: "Prompt Cache Key",
-        description: "xAI conversation-routing cache key \u2014 maps to Responses API `prompt_cache_key`."
-      })
-    }).optional().meta({
-      title: "xAI Provider Options",
-      description: "Allowlisted xAI provider options for grok-4.5."
-    })
+    xai: XaiProviderOptionsSchema.optional()
   }).optional().meta({
     title: "Provider Options",
     description: "Provider-specific options accepted for grok-4.5."
   })
 }).meta({
   title: "Grok45Config",
-  description: "Strict Responses API config for model grok-4.5. Level reasoning (low/high only), tunable sampling, no service tiers, structured output, vision, priced.",
+  description: "Strict Responses API config for model grok-4.5. Level reasoning (low/medium/high), tunable sampling, no service tiers, structured output, vision, Live Search tools, priced.",
   examples: [{ reasoning: { effort: "high" } }]
 });
 var Grok46ConfigSchema = zod.z.strictObject({
@@ -932,15 +1356,7 @@ var Grok46ConfigSchema = zod.z.strictObject({
     description: "Logical request timeout in milliseconds."
   }),
   providerOptions: zod.z.strictObject({
-    xai: zod.z.strictObject({
-      promptCacheKey: zod.z.string().min(1).optional().meta({
-        title: "Prompt Cache Key",
-        description: "xAI conversation-routing cache key \u2014 maps to Responses API `prompt_cache_key`."
-      })
-    }).optional().meta({
-      title: "xAI Provider Options",
-      description: "Allowlisted xAI provider options for grok-4.6."
-    })
+    xai: XaiProviderOptionsSchema.optional()
   }).optional().meta({
     title: "Provider Options",
     description: "Provider-specific options accepted for grok-4.6."
@@ -959,14 +1375,15 @@ var grok45ModelDescriptor = {
   capabilities: {
     reasoning: true,
     reasoningApi: "level",
-    admittedReasoningEfforts: ["low", "high"],
+    admittedReasoningEfforts: ["low", "medium", "high"],
     structuredOutput: true,
     nativeStructuredOutput: true,
     vision: true,
     audioInput: false,
     sampling: "tunable",
     caching: { explicit: false, minTokens: 0 },
-    grounding: false
+    grounding: true,
+    functionCalling: true
     // No serviceTiers key — grok-4.5 has no admitted service-tier vocabulary.
   },
   configSchema: Grok45ConfigSchema,
@@ -987,7 +1404,8 @@ var grok46ModelDescriptor = {
     audioInput: false,
     sampling: "tunable",
     caching: { explicit: false, minTokens: 0 },
-    grounding: false,
+    grounding: true,
+    functionCalling: true,
     serviceTiers: ["priority"]
   },
   configSchema: Grok46ConfigSchema,
@@ -1001,7 +1419,12 @@ var xaiModelDescriptors = [
 var xaiRegistry = core.createModelRegistry(xaiModelDescriptors);
 
 // src/pricing.ts
-var xaiPricingVersion = "xai-2026-08-12";
+var xaiPricingVersion = "xai-2026-08-24";
+var XAI_TOOL_RATE_MICRO_USD = {
+  web_search_calls: 5e3,
+  x_search_calls: 5e3
+};
+var XAI_TOOL_COUNTER_KEYS = ["web_search_calls", "x_search_calls"];
 var XAI_PRICING = Object.freeze({
   // ── grok-4.5 ──  $2.00/$6.00 (≤200k), $4.00/$12.00 (>200k); cached $0.30/$0.60
   "grok-4.5": {
@@ -1050,7 +1473,7 @@ function computeXaiCost(model, usage, tier) {
       usd: null,
       pricingVersion: xaiPricingVersion,
       confidence: "estimated",
-      details: { input: 0, cached: 0, output: 0 },
+      details: { input: 0, cached: 0, output: 0, tools: 0 },
       unpricedReason: `Unknown model "${model}"; no pricing entry found.`
     };
   }
@@ -1064,7 +1487,7 @@ function computeXaiCost(model, usage, tier) {
         usd: null,
         pricingVersion: xaiPricingVersion,
         confidence: "estimated",
-        details: { input: 0, cached: 0, output: 0 },
+        details: { input: 0, cached: 0, output: 0, tools: 0 },
         unpricedReason: `Unknown service tier "${tier}"; xai model "${model}" has no such tier, refusing to guess a pricing multiplier.`
       };
     }
@@ -1077,16 +1500,25 @@ function computeXaiCost(model, usage, tier) {
   const outputCost = Math.round(
     usage.outputTokens * base.outputPerM * factor / 1e6
   );
-  const microUsd = inputCost + cachedCost + outputCost;
+  const serverToolsRequested = usage.details["server_tools_requested"] === 1;
+  const missingRequestedCounters = usage.details["server_tools_missing"] === 1 || serverToolsRequested && usage.details["attachment_search_unpinned"] !== 1 && !XAI_TOOL_COUNTER_KEYS.some((key) => key in usage.details);
+  const attachmentUnpinned = usage.details["attachment_search_unpinned"] === 1;
+  const toolsCost = missingRequestedCounters ? 0 : XAI_TOOL_COUNTER_KEYS.reduce((sum, key) => {
+    const count = usage.details[key];
+    if (typeof count !== "number" || count <= 0) return sum;
+    return sum + Math.round(count * XAI_TOOL_RATE_MICRO_USD[key]);
+  }, 0);
+  const microUsd = inputCost + cachedCost + outputCost + toolsCost;
   return {
     microUsd,
     usd: microUsd / 1e6,
     pricingVersion: xaiPricingVersion,
-    confidence: "exact",
+    confidence: missingRequestedCounters || attachmentUnpinned ? "estimated" : "exact",
     details: {
       input: inputCost,
       cached: cachedCost,
-      output: outputCost
+      output: outputCost,
+      tools: toolsCost
     }
   };
 }
@@ -1121,6 +1553,7 @@ exports.XAI_FILE_MAX_BYTES = XAI_FILE_MAX_BYTES;
 exports.XAI_FILE_TTL_MAX_SECONDS = XAI_FILE_TTL_MAX_SECONDS;
 exports.XAI_FILE_TTL_MIN_SECONDS = XAI_FILE_TTL_MIN_SECONDS;
 exports.XAI_PRICING = XAI_PRICING;
+exports.XAI_TOOL_RATE_MICRO_USD = XAI_TOOL_RATE_MICRO_USD;
 exports.XaiFileStore = XaiFileStore;
 exports.buildXaiClient = buildXaiClient;
 exports.classifyXaiError = classifyXaiError;