@adaline/xai 1.1.0

package/dist/index.js

@@ -0,0 +1,2179 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BaseChatModel: () => BaseChatModel,
+  BaseChatModelOptions: () => BaseChatModelOptions,
+  Grok_2: () => Grok_2,
+  Grok_2_1212: () => Grok_2_1212,
+  Grok_2_1212_Literal: () => Grok_2_1212_Literal,
+  Grok_2_1212_Options: () => Grok_2_1212_Options,
+  Grok_2_1212_Schema: () => Grok_2_1212_Schema,
+  Grok_2_Latest: () => Grok_2_Latest,
+  Grok_2_Latest_Literal: () => Grok_2_Latest_Literal,
+  Grok_2_Latest_Options: () => Grok_2_Latest_Options,
+  Grok_2_Latest_Schema: () => Grok_2_Latest_Schema,
+  Grok_2_Literal: () => Grok_2_Literal,
+  Grok_2_Options: () => Grok_2_Options,
+  Grok_2_Schema: () => Grok_2_Schema,
+  Grok_3_Beta: () => Grok_3_Beta,
+  Grok_3_Beta_Literal: () => Grok_3_Beta_Literal,
+  Grok_3_Beta_Options: () => Grok_3_Beta_Options,
+  Grok_3_Beta_Schema: () => Grok_3_Beta_Schema,
+  Grok_3_Fast_Beta: () => Grok_3_Fast_Beta,
+  Grok_3_Fast_Beta_Literal: () => Grok_3_Fast_Beta_Literal,
+  Grok_3_Fast_Beta_Options: () => Grok_3_Fast_Beta_Options,
+  Grok_3_Fast_Beta_Schema: () => Grok_3_Fast_Beta_Schema,
+  Grok_3_Mini_Beta: () => Grok_3_Mini_Beta,
+  Grok_3_Mini_Beta_Literal: () => Grok_3_Mini_Beta_Literal,
+  Grok_3_Mini_Beta_Options: () => Grok_3_Mini_Beta_Options,
+  Grok_3_Mini_Beta_Schema: () => Grok_3_Mini_Beta_Schema,
+  Grok_3_Mini_Fast_Beta: () => Grok_3_Mini_Fast_Beta,
+  Grok_3_Mini_Fast_Beta_Literal: () => Grok_3_Mini_Fast_Beta_Literal,
+  Grok_3_Mini_Fast_Beta_Options: () => Grok_3_Mini_Fast_Beta_Options,
+  Grok_3_Mini_Fast_Beta_Schema: () => Grok_3_Mini_Fast_Beta_Schema,
+  Grok_4: () => Grok_4,
+  Grok_4_0709: () => Grok_4_0709,
+  Grok_4_0709_Literal: () => Grok_4_0709_Literal,
+  Grok_4_0709_Options: () => Grok_4_0709_Options,
+  Grok_4_0709_Schema: () => Grok_4_0709_Schema,
+  Grok_4_1_Fast_Non_Reasoning: () => Grok_4_1_Fast_Non_Reasoning,
+  Grok_4_1_Fast_Non_Reasoning_Literal: () => Grok_4_1_Fast_Non_Reasoning_Literal,
+  Grok_4_1_Fast_Non_Reasoning_Options: () => Grok_4_1_Fast_Non_Reasoning_Options,
+  Grok_4_1_Fast_Non_Reasoning_Schema: () => Grok_4_1_Fast_Non_Reasoning_Schema,
+  Grok_4_1_Fast_Reasoning: () => Grok_4_1_Fast_Reasoning,
+  Grok_4_1_Fast_Reasoning_Literal: () => Grok_4_1_Fast_Reasoning_Literal,
+  Grok_4_1_Fast_Reasoning_Options: () => Grok_4_1_Fast_Reasoning_Options,
+  Grok_4_1_Fast_Reasoning_Schema: () => Grok_4_1_Fast_Reasoning_Schema,
+  Grok_4_Fast_Non_Reasoning: () => Grok_4_Fast_Non_Reasoning,
+  Grok_4_Fast_Non_Reasoning_Literal: () => Grok_4_Fast_Non_Reasoning_Literal,
+  Grok_4_Fast_Non_Reasoning_Options: () => Grok_4_Fast_Non_Reasoning_Options,
+  Grok_4_Fast_Non_Reasoning_Schema: () => Grok_4_Fast_Non_Reasoning_Schema,
+  Grok_4_Fast_Reasoning: () => Grok_4_Fast_Reasoning,
+  Grok_4_Fast_Reasoning_Literal: () => Grok_4_Fast_Reasoning_Literal,
+  Grok_4_Fast_Reasoning_Options: () => Grok_4_Fast_Reasoning_Options,
+  Grok_4_Fast_Reasoning_Schema: () => Grok_4_Fast_Reasoning_Schema,
+  Grok_4_Literal: () => Grok_4_Literal,
+  Grok_4_Options: () => Grok_4_Options,
+  Grok_4_Schema: () => Grok_4_Schema,
+  Grok_Code_Fast_1: () => Grok_Code_Fast_1,
+  Grok_Code_Fast_1_Literal: () => Grok_Code_Fast_1_Literal,
+  Grok_Code_Fast_1_Options: () => Grok_Code_Fast_1_Options,
+  Grok_Code_Fast_1_Schema: () => Grok_Code_Fast_1_Schema,
+  ProviderLiteral: () => ProviderLiteral,
+  XAI: () => XAI,
+  XAIChatModelConfigs: () => chat_model_exports,
+  XAIChatModelModalities: () => XAIChatModelModalities,
+  XAIChatModelModalitiesEnum: () => XAIChatModelModalitiesEnum,
+  XAIChatModelRoles: () => XAIChatModelRoles,
+  XAIChatModelRolesMap: () => XAIChatModelRolesMap,
+  XAIChatModelTextModalities: () => XAIChatModelTextModalities,
+  XAIChatModelTextModalitiesEnum: () => XAIChatModelTextModalitiesEnum,
+  XAIChatModelTextToolModalities: () => XAIChatModelTextToolModalities,
+  XAIChatModelTextToolModalitiesEnum: () => XAIChatModelTextToolModalitiesEnum,
+  XAIChatRequest: () => XAIChatRequest,
+  XAIChatRequestAssistantMessage: () => XAIChatRequestAssistantMessage,
+  XAIChatRequestImageContent: () => XAIChatRequestImageContent,
+  XAIChatRequestMessage: () => XAIChatRequestMessage,
+  XAIChatRequestResponseFormat: () => XAIChatRequestResponseFormat,
+  XAIChatRequestSystemMessage: () => XAIChatRequestSystemMessage,
+  XAIChatRequestTextContent: () => XAIChatRequestTextContent,
+  XAIChatRequestTool: () => XAIChatRequestTool,
+  XAIChatRequestToolCallContent: () => XAIChatRequestToolCallContent,
+  XAIChatRequestToolChoiceEnum: () => XAIChatRequestToolChoiceEnum,
+  XAIChatRequestToolChoiceFunction: () => XAIChatRequestToolChoiceFunction,
+  XAIChatRequestToolMessage: () => XAIChatRequestToolMessage,
+  XAIChatRequestUserMessage: () => XAIChatRequestUserMessage,
+  XAICompleteChatResponse: () => XAICompleteChatResponse,
+  XAIStreamChatResponse: () => XAIStreamChatResponse,
+  XAIToolCallsCompleteChatResponse: () => XAIToolCallsCompleteChatResponse,
+  XAIToolCallsStreamChatResponse: () => XAIToolCallsStreamChatResponse
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/provider/provider.xai.ts
+var import_provider19 = require("@adaline/provider");
+
+// src/models/chat-models/base-chat-model.xai.ts
+var import_zod5 = require("zod");
+var import_provider = require("@adaline/provider");
+var import_types3 = require("@adaline/types");
+
+// src/models/pricing.json
+var pricing_default = {
+  "grok-2": {
+    modelName: "grok-2",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 2,
+            outputPricePerMillion: 10
+          }
+        }
+      }
+    ]
+  },
+  "grok-2-latest": {
+    modelName: "grok-2-latest",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 2,
+            outputPricePerMillion: 10
+          }
+        }
+      }
+    ]
+  },
+  "grok-2-1212": {
+    modelName: "grok-2-1212",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 2,
+            outputPricePerMillion: 10
+          }
+        }
+      }
+    ]
+  },
+  "grok-2-vision": {
+    modelName: "grok-2-vision",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 2,
+            outputPricePerMillion: 10
+          }
+        }
+      }
+    ]
+  },
+  "grok-2-vision-latest": {
+    modelName: "grok-2-vision-latest",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 2,
+            outputPricePerMillion: 10
+          }
+        }
+      }
+    ]
+  },
+  "grok-2-vision-1212": {
+    modelName: "grok-2-vision-1212",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 2,
+            outputPricePerMillion: 10
+          }
+        }
+      }
+    ]
+  },
+  "grok-3-beta": {
+    modelName: "grok-3-beta",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 3,
+            outputPricePerMillion: 15
+          }
+        }
+      }
+    ]
+  },
+  "grok-3-fast-beta": {
+    modelName: "grok-3-fast-beta",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 5,
+            outputPricePerMillion: 25
+          }
+        }
+      }
+    ]
+  },
+  "grok-3-mini-beta": {
+    modelName: "grok-3-mini-beta",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 0.3,
+            outputPricePerMillion: 0.5
+          }
+        }
+      }
+    ]
+  },
+  "grok-3-mini-fast-beta": {
+    modelName: "grok-3-mini-fast-beta",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 0.6,
+            outputPricePerMillion: 4
+          }
+        }
+      }
+    ]
+  },
+  "grok-4": {
+    modelName: "grok-4",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 6,
+            outputPricePerMillion: 18
+          }
+        }
+      }
+    ]
+  },
+  "grok-4-0709": {
+    modelName: "grok-4-0709",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 6,
+            outputPricePerMillion: 18
+          }
+        }
+      }
+    ]
+  },
+  "grok-4-fast-reasoning": {
+    modelName: "grok-4-fast-reasoning",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 3,
+            outputPricePerMillion: 12
+          }
+        }
+      }
+    ]
+  },
+  "grok-4-fast-non-reasoning": {
+    modelName: "grok-4-fast-non-reasoning",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 3,
+            outputPricePerMillion: 12
+          }
+        }
+      }
+    ]
+  },
+  "grok-4.1-fast-reasoning": {
+    modelName: "grok-4.1-fast-reasoning",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 3,
+            outputPricePerMillion: 12
+          }
+        }
+      }
+    ]
+  },
+  "grok-4.1-fast-non-reasoning": {
+    modelName: "grok-4.1-fast-non-reasoning",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 3,
+            outputPricePerMillion: 12
+          }
+        }
+      }
+    ]
+  },
+  "grok-code-fast-1": {
+    modelName: "grok-code-fast-1",
+    currency: "USD",
+    tokenRanges: [
+      {
+        minTokens: 0,
+        maxTokens: null,
+        prices: {
+          base: {
+            inputPricePerMillion: 0.3,
+            outputPricePerMillion: 0.5
+          }
+        }
+      }
+    ]
+  }
+};
+
+// src/models/chat-models/types/roles.chat-model.xai.ts
+var import_zod = require("zod");
+var import_types = require("@adaline/types");
+var XAIChatModelRoles = import_zod.z.enum([import_types.SystemRoleLiteral, import_types.UserRoleLiteral, import_types.AssistantRoleLiteral, import_types.ToolRoleLiteral]);
+var XAIChatModelRolesMap = {
+  system: import_types.SystemRoleLiteral,
+  user: import_types.UserRoleLiteral,
+  assistant: import_types.AssistantRoleLiteral,
+  tool: import_types.ToolRoleLiteral
+};
+
+// src/models/chat-models/types/modalities.chat-model.xai.ts
+var import_zod2 = require("zod");
+var import_types2 = require("@adaline/types");
+var XAIChatModelModalities = [
+  import_types2.TextModalityLiteral,
+  import_types2.ImageModalityLiteral,
+  import_types2.ToolCallModalityLiteral,
+  import_types2.ToolResponseModalityLiteral
+];
+var XAIChatModelModalitiesEnum = import_zod2.z.enum([
+  import_types2.TextModalityLiteral,
+  import_types2.ImageModalityLiteral,
+  import_types2.ToolCallModalityLiteral,
+  import_types2.ToolResponseModalityLiteral
+]);
+var XAIChatModelTextModalities = [import_types2.TextModalityLiteral];
+var XAIChatModelTextModalitiesEnum = import_zod2.z.enum([import_types2.TextModalityLiteral]);
+var XAIChatModelTextToolModalities = [
+  import_types2.TextModalityLiteral,
+  import_types2.ToolCallModalityLiteral,
+  import_types2.ToolResponseModalityLiteral
+];
+var XAIChatModelTextToolModalitiesEnum = import_zod2.z.enum([import_types2.TextModalityLiteral, import_types2.ToolCallModalityLiteral, import_types2.ToolResponseModalityLiteral]);
+
+// src/models/chat-models/types/response.chat-model.xai.ts
+var import_zod3 = require("zod");
+var XAIBaseLogProb = import_zod3.z.object({
+  token: import_zod3.z.string(),
+  logprob: import_zod3.z.number(),
+  bytes: import_zod3.z.array(import_zod3.z.number()).nullable()
+});
+var XAILogProb = import_zod3.z.object({
+  content: import_zod3.z.array(
+    XAIBaseLogProb.extend({
+      top_logprobs: import_zod3.z.array(XAIBaseLogProb)
+    })
+  ).nullable().optional(),
+  refusal: import_zod3.z.array(
+    XAIBaseLogProb.extend({
+      top_logprobs: import_zod3.z.array(XAIBaseLogProb)
+    })
+  ).nullable().optional()
+}).nullable();
+var XAIToolCallsCompleteChatResponse = import_zod3.z.array(
+  import_zod3.z.object({
+    id: import_zod3.z.string().min(1),
+    type: import_zod3.z.enum(["function"]),
+    function: import_zod3.z.object({
+      name: import_zod3.z.string(),
+      arguments: import_zod3.z.string()
+    })
+  })
+);
+var XAICompleteChatResponse = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  object: import_zod3.z.literal("chat.completion"),
+  created: import_zod3.z.number(),
+  model: import_zod3.z.string(),
+  system_fingerprint: import_zod3.z.string().nullable().optional(),
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      index: import_zod3.z.number(),
+      message: import_zod3.z.object({
+        role: import_zod3.z.string(),
+        content: import_zod3.z.string().nullable().optional(),
+        tool_calls: XAIToolCallsCompleteChatResponse.optional(),
+        refusal: import_zod3.z.string().nullable().optional()
+      }),
+      logprobs: XAILogProb.optional(),
+      finish_reason: import_zod3.z.string()
+    })
+  ),
+  usage: import_zod3.z.object({
+    prompt_tokens: import_zod3.z.number(),
+    completion_tokens: import_zod3.z.number(),
+    total_tokens: import_zod3.z.number(),
+    reasoning_tokens: import_zod3.z.number().optional()
+  })
+});
+var XAIToolCallsStreamChatResponse = import_zod3.z.array(
+  import_zod3.z.object({
+    index: import_zod3.z.number().int(),
+    id: import_zod3.z.string().min(1).optional(),
+    type: import_zod3.z.enum(["function"]).optional(),
+    function: import_zod3.z.object({
+      name: import_zod3.z.string().min(1).optional(),
+      arguments: import_zod3.z.string().optional()
+    }).optional()
+  })
+);
+var XAIStreamChatResponse = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  object: import_zod3.z.string(),
+  created: import_zod3.z.number(),
+  model: import_zod3.z.string(),
+  system_fingerprint: import_zod3.z.string().nullable().optional(),
+  choices: import_zod3.z.array(
+    import_zod3.z.object({
+      index: import_zod3.z.number(),
+      delta: import_zod3.z.object({
+        content: import_zod3.z.string().nullable().optional(),
+        tool_calls: XAIToolCallsStreamChatResponse.optional(),
+        refusal: import_zod3.z.string().nullable().optional()
+      }).or(import_zod3.z.object({})),
+      logprobs: XAILogProb.optional(),
+      finish_reason: import_zod3.z.string().nullable().optional()
+    })
+  ),
+  usage: import_zod3.z.object({
+    prompt_tokens: import_zod3.z.number(),
+    completion_tokens: import_zod3.z.number(),
+    total_tokens: import_zod3.z.number(),
+    reasoning_tokens: import_zod3.z.number().optional()
+  }).nullable().optional()
+});
+
+// src/models/chat-models/types/request.chat-model.xai.ts
+var import_zod4 = require("zod");
+var XAIChatRequestTool = import_zod4.z.object({
+  type: import_zod4.z.literal("function"),
+  function: import_zod4.z.object({
+    name: import_zod4.z.string().min(1),
+    description: import_zod4.z.string().min(1).optional(),
+    strict: import_zod4.z.boolean().optional(),
+    parameters: import_zod4.z.any()
+  })
+});
+var XAIChatRequestToolChoiceEnum = import_zod4.z.enum(["none", "auto", "required"]);
+var XAIChatRequestToolChoiceFunction = import_zod4.z.object({
+  type: import_zod4.z.literal("function"),
+  function: import_zod4.z.object({
+    name: import_zod4.z.string().min(1)
+  })
+});
+var XAIChatRequestResponseFormat = import_zod4.z.object({
+  type: import_zod4.z.enum(["text", "json_object"])
+}).or(
+  import_zod4.z.object({
+    type: import_zod4.z.literal("json_schema"),
+    json_schema: import_zod4.z.object({
+      name: import_zod4.z.string().min(1),
+      description: import_zod4.z.string().min(1).optional(),
+      strict: import_zod4.z.boolean().optional(),
+      schema: import_zod4.z.any()
+    })
+  })
+);
+var XAIChatRequestTextContent = import_zod4.z.object({
+  text: import_zod4.z.string().min(1),
+  type: import_zod4.z.literal("text")
+});
+var XAIChatRequestImageContent = import_zod4.z.object({
+  type: import_zod4.z.literal("image_url"),
+  image_url: import_zod4.z.object({
+    url: import_zod4.z.string().min(1),
+    detail: import_zod4.z.enum(["low", "high", "auto"]).optional()
+  })
+});
+var XAIChatRequestToolCallContent = import_zod4.z.object({
+  id: import_zod4.z.string().min(1),
+  type: import_zod4.z.literal("function"),
+  function: import_zod4.z.object({
+    name: import_zod4.z.string().min(1),
+    arguments: import_zod4.z.string().min(1)
+  })
+});
+var XAIChatRequestSystemMessage = import_zod4.z.object({
+  role: import_zod4.z.literal("system"),
+  content: import_zod4.z.string().min(1).or(import_zod4.z.array(XAIChatRequestTextContent).min(1))
+});
+var XAIChatRequestUserMessage = import_zod4.z.object({
+  role: import_zod4.z.literal("user"),
+  content: import_zod4.z.string().min(1).or(import_zod4.z.array(import_zod4.z.union([XAIChatRequestTextContent, XAIChatRequestImageContent])).min(1))
+});
+var XAIChatRequestAssistantMessage = import_zod4.z.object({
+  role: import_zod4.z.literal("assistant"),
+  content: import_zod4.z.string().min(1).or(import_zod4.z.array(XAIChatRequestTextContent).min(1)).optional(),
+  tool_calls: import_zod4.z.array(XAIChatRequestToolCallContent).min(1).optional()
+});
+var XAIChatRequestToolMessage = import_zod4.z.object({
+  role: import_zod4.z.literal("tool"),
+  tool_call_id: import_zod4.z.string().min(1),
+  content: import_zod4.z.string().min(1)
+});
+var XAIChatRequestMessage = import_zod4.z.union([
+  XAIChatRequestSystemMessage,
+  XAIChatRequestUserMessage,
+  XAIChatRequestAssistantMessage,
+  XAIChatRequestToolMessage
+]);
+var XAIChatRequest = import_zod4.z.object({
+  model: import_zod4.z.string().min(1).optional(),
+  messages: import_zod4.z.array(XAIChatRequestMessage).min(1),
+  frequency_penalty: import_zod4.z.number().min(-2).max(2).nullable().optional(),
+  logprobs: import_zod4.z.boolean().nullable().optional(),
+  top_logprobs: import_zod4.z.number().min(0).max(20).nullable().optional(),
+  max_tokens: import_zod4.z.number().min(0).nullable().optional(),
+  presence_penalty: import_zod4.z.number().min(-2).max(2).nullable().optional(),
+  response_format: XAIChatRequestResponseFormat.optional(),
+  seed: import_zod4.z.number().nullable().optional(),
+  stop: import_zod4.z.string().or(import_zod4.z.array(import_zod4.z.string()).max(4)).nullable().optional(),
+  temperature: import_zod4.z.number().min(0).max(2).nullable().optional(),
+  top_p: import_zod4.z.number().min(0).max(1).nullable().optional(),
+  tools: import_zod4.z.array(XAIChatRequestTool).optional(),
+  tool_choice: XAIChatRequestToolChoiceEnum.or(XAIChatRequestToolChoiceFunction).optional(),
+  reasoning_effort: import_zod4.z.enum(["low", "high"]).optional()
+});
+
+// src/models/chat-models/base-chat-model.xai.ts
+var BaseChatModelOptions = import_zod5.z.object({
+  modelName: import_zod5.z.string(),
+  apiKey: import_zod5.z.string(),
+  baseUrl: import_zod5.z.string().url().optional(),
+  completeChatUrl: import_zod5.z.string().url().optional(),
+  streamChatUrl: import_zod5.z.string().url().optional()
+});
+var BaseChatModel = class {
+  constructor(modelSchema, options) {
+    this.version = "v1";
+    const parsedOptions = BaseChatModelOptions.parse(options);
+    this.modelSchema = modelSchema;
+    this.modelName = parsedOptions.modelName;
+    this.apiKey = parsedOptions.apiKey;
+    this.baseUrl = (0, import_provider.urlWithoutTrailingSlash)(parsedOptions.baseUrl || XAI.baseUrl);
+    this.streamChatUrl = (0, import_provider.urlWithoutTrailingSlash)(parsedOptions.streamChatUrl || `${this.baseUrl}/chat/completions`);
+    this.completeChatUrl = (0, import_provider.urlWithoutTrailingSlash)(parsedOptions.completeChatUrl || `${this.baseUrl}/chat/completions`);
+  }
+  getDefaultBaseUrl() {
+    return this.baseUrl;
+  }
+  getDefaultHeaders() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  getDefaultParams() {
+    return {
+      model: this.modelName
+    };
+  }
+  getRetryDelay(responseHeaders) {
+    const parseDuration = (duration) => {
+      const regex = /(\d+)(h|m|s|ms)/g;
+      const timeUnits = {
+        h: 36e5,
+        m: 6e4,
+        s: 1e3,
+        ms: 1
+      };
+      let match;
+      let totalMs = 0;
+      while ((match = regex.exec(duration)) !== null) {
+        const value = parseInt(match[1]);
+        const unit = match[2];
+        totalMs += value * timeUnits[unit];
+      }
+      return totalMs;
+    };
+    let resetRequestsDelayMs = 0;
+    let resetTokensDelayMs = 0;
+    const shouldRetry = true;
+    if (responseHeaders["x-ratelimit-reset-requests"]) {
+      resetRequestsDelayMs = parseDuration(responseHeaders["x-ratelimit-reset-requests"]);
+    }
+    if (responseHeaders["x-ratelimit-reset-tokens"]) {
+      resetTokensDelayMs = parseDuration(responseHeaders["x-ratelimit-reset-tokens"]);
+    }
+    const delayMs = Math.max(resetRequestsDelayMs, resetTokensDelayMs);
+    return { shouldRetry, delayMs };
+  }
+  getTokenCount(messages) {
+    return messages.reduce((acc, message) => {
+      return acc + message.content.map((content) => content.modality === "text" ? content.value : "").join(" ").length;
+    }, 0);
+  }
+  transformModelRequest(request) {
+    const safeRequest = XAIChatRequest.safeParse(request);
+    if (!safeRequest.success) {
+      throw new import_provider.InvalidModelRequestError({ info: "Invalid model request", cause: safeRequest.error });
+    }
+    const parsedRequest = safeRequest.data;
+    const modelName = parsedRequest.model;
+    if (parsedRequest.tool_choice && (!parsedRequest.tools || parsedRequest.tools.length === 0)) {
+      throw new import_provider.InvalidModelRequestError({
+        info: `Invalid model request for model : '${this.modelName}'`,
+        cause: new Error("'tools' are required when 'tool_choice' is specified")
+      });
+    }
+    const _config = {};
+    if (parsedRequest.response_format) {
+      _config.responseFormat = parsedRequest.response_format.type;
+      if (parsedRequest.response_format.type === "json_schema") {
+        _config.responseSchema = {
+          name: parsedRequest.response_format.json_schema.name,
+          description: parsedRequest.response_format.json_schema.description || "",
+          strict: parsedRequest.response_format.json_schema.strict,
+          schema: parsedRequest.response_format.json_schema.schema
+        };
+      }
+    }
+    if (parsedRequest.tool_choice) {
+      if (typeof parsedRequest.tool_choice === "string") {
+        _config.toolChoice = parsedRequest.tool_choice;
+      } else {
+        _config.toolChoice = parsedRequest.tool_choice.function.name;
+      }
+    }
+    _config.seed = parsedRequest.seed;
+    _config.maxTokens = parsedRequest.max_tokens;
+    _config.temperature = parsedRequest.temperature;
+    _config.topP = parsedRequest.top_p;
+    _config.presencePenalty = parsedRequest.presence_penalty;
+    _config.frequencyPenalty = parsedRequest.frequency_penalty;
+    _config.stop = parsedRequest.stop;
+    _config.logProbs = parsedRequest.logprobs;
+    _config.topLogProbs = parsedRequest.top_logprobs;
+    _config.reasoningEffort = parsedRequest.reasoning_effort;
+    const config = (0, import_types3.Config)().parse((0, import_provider.removeUndefinedEntries)(_config));
+    const messages = [];
+    const toolCallMap = {};
+    parsedRequest.messages.forEach((message) => {
+      const role = message.role;
+      switch (role) {
+        case "system":
+          {
+            const content = message.content;
+            if (typeof content === "string") {
+              messages.push({
+                role,
+                content: [{ modality: import_types3.TextModalityLiteral, value: content }]
+              });
+            } else {
+              const _content = content.map((c) => {
+                return { modality: import_types3.TextModalityLiteral, value: c.text };
+              });
+              messages.push({ role, content: _content });
+            }
+          }
+          break;
+        case "user":
+          {
+            const content = message.content;
+            if (typeof content === "string") {
+              messages.push({
+                role,
+                content: [{ modality: import_types3.TextModalityLiteral, value: content }]
+              });
+            } else {
+              const _content = content.map((c) => {
+                if (c.type === "text") {
+                  return { modality: import_types3.TextModalityLiteral, value: c.text };
+                } else {
+                  if (c.image_url.url.startsWith("data:")) {
+                    return {
+                      modality: import_types3.ImageModalityLiteral,
+                      detail: c.image_url.detail || "auto",
+                      value: {
+                        type: import_types3.Base64ImageContentTypeLiteral,
+                        base64: c.image_url.url,
+                        mediaType: (0, import_provider.getMimeTypeFromBase64)(c.image_url.url)
+                      }
+                    };
+                  } else {
+                    return {
+                      modality: import_types3.ImageModalityLiteral,
+                      detail: c.image_url.detail || "auto",
+                      value: { type: import_types3.UrlImageContentTypeLiteral, url: c.image_url.url }
+                    };
+                  }
+                }
+              });
+              messages.push({ role, content: _content });
+            }
+          }
+          break;
+        case "assistant":
+          {
+            const assistantContent = [];
+            if (!message.content && !message.tool_calls) {
+              throw new import_provider.InvalidModelRequestError({
+                info: `Invalid model request for model : '${this.modelName}'`,
+                cause: new Error("one of'content' or 'tool_calls' must be provided")
+              });
+            }
+            if (message.content) {
+              const content = message.content;
+              if (typeof content === "string") {
+                assistantContent.push({ modality: import_types3.TextModalityLiteral, value: content });
+              } else {
+                content.forEach((c) => {
+                  assistantContent.push({ modality: import_types3.TextModalityLiteral, value: c.text });
+                });
+              }
+            }
+            if (message.tool_calls) {
+              const toolCalls = message.tool_calls;
+              toolCalls.forEach((toolCall, index) => {
+                const toolCallContent = {
+                  modality: import_types3.ToolCallModalityLiteral,
+                  id: toolCall.id,
+                  index,
+                  name: toolCall.function.name,
+                  arguments: toolCall.function.arguments
+                };
+                assistantContent.push(toolCallContent);
+                toolCallMap[toolCallContent.id] = toolCallContent;
+              });
+            }
+            messages.push({ role, content: assistantContent });
+          }
+          break;
+        case "tool":
+          {
+            const toolResponse = message;
+            messages.push({
+              role,
+              content: [
+                {
+                  modality: import_types3.ToolResponseModalityLiteral,
+                  id: toolResponse.tool_call_id,
+                  index: toolCallMap[toolResponse.tool_call_id].index,
+                  name: toolCallMap[toolResponse.tool_call_id].name,
+                  data: toolResponse.content
+                }
+              ]
+            });
+          }
+          break;
+      }
+    });
+    const tools = [];
+    if (parsedRequest.tools) {
+      parsedRequest.tools.forEach((tool) => {
+        tools.push({
+          type: "function",
+          definition: {
+            schema: {
+              name: tool.function.name,
+              description: tool.function.description || "",
+              strict: tool.function.strict,
+              parameters: tool.function.parameters
+            }
+          }
+        });
+      });
+    }
+    return {
+      modelName,
+      config,
+      messages,
+      tools: tools.length > 0 ? tools : void 0
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  transformConfig(config, messages, tools) {
+    const _toolChoice = config.toolChoice;
+    delete config.toolChoice;
+    const _parsedConfig = this.modelSchema.config.schema.safeParse(config);
+    if (!_parsedConfig.success) {
+      throw new import_provider.InvalidConfigError({
+        info: `Invalid config for model : '${this.modelName}'`,
+        cause: _parsedConfig.error
+      });
+    }
+    const parsedConfig = _parsedConfig.data;
+    if (_toolChoice !== void 0) {
+      parsedConfig.toolChoice = _toolChoice;
+    }
+    Object.keys(parsedConfig).forEach((key) => {
+      if (!(key in this.modelSchema.config.def)) {
+        throw new import_provider.InvalidConfigError({
+          info: `Invalid config for model : '${this.modelName}'`,
+          cause: new Error(`Invalid config key : '${key}', 
+            available keys : [${Object.keys(this.modelSchema.config.def).join(", ")}]`)
+        });
+      }
+    });
+    const transformedConfig = Object.keys(parsedConfig).reduce((acc, key) => {
+      const def = this.modelSchema.config.def[key];
+      const paramKey = def.param;
+      const paramValue = parsedConfig[key];
+      if (paramKey === "max_tokens" && def.type === "range" && paramValue === 0) {
+        acc[paramKey] = def.max;
+      } else {
+        acc[paramKey] = paramValue;
+      }
+      return acc;
+    }, {});
+    if (transformedConfig.top_logprobs && !transformedConfig.logprobs) {
+      throw new import_provider.InvalidConfigError({
+        info: `Invalid config for model : '${this.modelName}'`,
+        cause: new Error("'logprobs' must be 'true' when 'top_logprobs' is specified")
+      });
+    }
+    if ("tool_choice" in transformedConfig && transformedConfig.tool_choice !== void 0) {
+      const toolChoice2 = transformedConfig.tool_choice;
+      if (!tools || tools && tools.length === 0) {
+        throw new import_provider.InvalidConfigError({
+          info: `Invalid config for model : '${this.modelName}'`,
+          cause: new Error("'tools' are required when 'toolChoice' is specified")
+        });
+      } else if (tools && tools.length > 0) {
+        const configToolChoice = this.modelSchema.config.def.toolChoice;
+        if (!configToolChoice.choices.includes(toolChoice2)) {
+          if (tools.map((tool) => tool.definition.schema.name).includes(toolChoice2)) {
+            transformedConfig.tool_choice = { type: "function", function: { name: toolChoice2 } };
+          } else {
+            throw new import_provider.InvalidConfigError({
+              info: `Invalid config for model : '${this.modelName}'`,
+              cause: new Error(`toolChoice : '${toolChoice2}' is not part of provided 'tools' names or 
+                one of [${configToolChoice.choices.join(", ")}]`)
+            });
+          }
+        }
+      }
+    }
+    if ("response_format" in transformedConfig && transformedConfig.response_format !== void 0) {
+      const responseFormat2 = transformedConfig.response_format;
+      if (responseFormat2 === "json_schema") {
+        if (!("response_schema" in transformedConfig)) {
+          throw new import_provider.InvalidConfigError({
+            info: `Invalid config for model : '${this.modelName}'`,
+            cause: new Error("'responseSchema' is required in config when 'responseFormat' is 'json_schema'")
+          });
+        } else {
+          transformedConfig.response_format = {
+            type: "json_schema",
+            json_schema: transformedConfig.response_schema
+          };
+          delete transformedConfig.response_schema;
+        }
+      } else {
+        transformedConfig.response_format = { type: responseFormat2 };
+      }
+    }
+    return transformedConfig;
+  }
+  transformMessages(messages) {
+    if (!messages || messages && messages.length === 0) {
+      return { messages: [] };
+    }
+    const parsedMessages = messages.map((message) => {
+      const parsedMessage = (0, import_types3.Message)().safeParse(message);
+      if (!parsedMessage.success) {
+        throw new import_provider.InvalidMessagesError({ info: "Invalid messages", cause: parsedMessage.error });
+      }
+      return parsedMessage.data;
+    });
+    parsedMessages.forEach((message) => {
+      message.content.forEach((content) => {
+        if (!this.modelSchema.modalities.includes(content.modality)) {
+          throw new import_provider.InvalidMessagesError({
+            info: `Invalid message content for model : '${this.modelName}'`,
+            cause: new Error(`model : '${this.modelName}' does not support modality : '${content.modality}', 
+              available modalities : [${this.modelSchema.modalities.join(", ")}]`)
+          });
+        }
+      });
+    });
+    parsedMessages.forEach((message) => {
+      if (!Object.keys(this.modelSchema.roles).includes(message.role)) {
+        throw new import_provider.InvalidMessagesError({
+          info: `Invalid message content for model : '${this.modelName}'`,
+          cause: new Error(`model : '${this.modelName}' does not support role : '${message.role}', 
+            available roles : [${Object.keys(this.modelSchema.roles).join(", ")}]`)
+        });
+      }
+    });
+    parsedMessages.forEach((message) => {
+      message.content = message.content.filter(
+        (content) => content.modality !== "error" && content.modality !== "search-result"
+      );
+    });
+    const transformedMessages = parsedMessages.map((message) => {
+      switch (message.role) {
+        case import_types3.SystemRoleLiteral: {
+          const textContent = [];
+          message.content.forEach((content) => {
+            if (content.modality === import_types3.TextModalityLiteral) {
+              textContent.push({ type: "text", text: content.value });
+            } else {
+              throw new import_provider.InvalidMessagesError({
+                info: `Invalid message content for model : '${this.modelName}'`,
+                cause: new Error(`model : '${this.modelName}' does not support modality : '${content.modality}' for role : 'system'`)
+              });
+            }
+          });
+          return { role: "system", content: textContent };
+        }
+        case import_types3.UserRoleLiteral: {
+          const userContent = [];
+          message.content.forEach((content) => {
+            if (content.modality === import_types3.TextModalityLiteral) {
+              userContent.push({ type: "text", text: content.value });
+            } else if (content.modality === import_types3.ImageModalityLiteral) {
+              if (content.value.type === import_types3.Base64ImageContentTypeLiteral) {
+                userContent.push({
+                  type: "image_url",
+                  image_url: { url: content.value.base64, detail: content.detail }
+                });
+              } else if (content.value.type === import_types3.UrlImageContentTypeLiteral) {
+                userContent.push({
+                  type: "image_url",
+                  image_url: { url: content.value.url, detail: content.detail }
+                });
+              }
+            } else {
+              throw new import_provider.InvalidMessagesError({
+                info: `Invalid message content for model : '${this.modelName}'`,
+                cause: new Error(`model : '${this.modelName}' does not support modality : '${content.modality}' for role : 'user'`)
+              });
+            }
+          });
+          return { role: "user", content: userContent };
+        }
+        case import_types3.AssistantRoleLiteral: {
+          const textContent = [];
+          const toolCalls = [];
+          message.content.forEach((content) => {
+            if (content.modality === import_types3.TextModalityLiteral) {
+              textContent.push({ type: "text", text: content.value });
+            } else if (content.modality === import_types3.ToolCallModalityLiteral) {
+              toolCalls.push({
+                id: content.id,
+                type: "function",
+                function: { name: content.name, arguments: content.arguments }
+              });
+            } else {
+              throw new import_provider.InvalidMessagesError({
+                info: `Invalid message content for model : '${this.modelName}'`,
+                cause: new Error(`model : '${this.modelName}' does not support modality : '${content.modality}' for role : 'assistant'`)
+              });
+            }
+          });
+          if (textContent.length > 0 && toolCalls.length > 0) {
+            return { role: "assistant", content: textContent, tool_calls: toolCalls };
+          } else if (textContent.length > 0) {
+            return { role: "assistant", content: textContent };
+          } else if (toolCalls.length > 0) {
+            return { role: "assistant", tool_calls: toolCalls };
+          } else {
+            throw new import_provider.InvalidMessagesError({
+              info: `Invalid message content for model : '${this.modelName}'`,
+              cause: new Error("assistant message must have at least one text or tool_call content")
+            });
+          }
+        }
+        case import_types3.ToolRoleLiteral: {
+          const toolResponseContent = message.content.find(
+            (content) => content.modality === import_types3.ToolResponseModalityLiteral
+          );
+          if (!toolResponseContent) {
+            throw new import_provider.InvalidMessagesError({
+              info: `Invalid message content for model : '${this.modelName}'`,
+              cause: new Error("tool message must have tool_response content")
+            });
+          }
+          return {
+            role: "tool",
+            tool_call_id: toolResponseContent.id,
+            content: typeof toolResponseContent.data === "string" ? toolResponseContent.data : JSON.stringify(toolResponseContent.data)
+          };
+        }
+        default:
+          throw new import_provider.InvalidMessagesError({
+            info: `Invalid message content for model : '${this.modelName}'`,
+            cause: new Error(`model : '${this.modelName}' does not support role : '${message.role}'`)
+          });
+      }
+    });
+    return { messages: transformedMessages };
+  }
+  transformTools(tools) {
+    if (!tools || tools && tools.length === 0) {
+      return {};
+    }
+    if (!this.modelSchema.modalities.includes(import_types3.ToolCallModalityLiteral)) {
+      throw new import_provider.InvalidToolsError({
+        info: `Invalid tools for model : '${this.modelName}'`,
+        cause: new Error(`model : '${this.modelName}' does not support tools`)
+      });
+    }
+    const parsedTools = tools.map((tool) => {
+      const parsedTool = (0, import_types3.Tool)().safeParse(tool);
+      if (!parsedTool.success) {
+        throw new import_provider.InvalidToolsError({ info: "Invalid tools", cause: parsedTool.error });
+      }
+      return parsedTool.data;
+    });
+    const transformedTools = parsedTools.map((tool) => ({
+      type: "function",
+      function: tool.definition.schema
+    }));
+    return { tools: transformedTools };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getCompleteChatUrl(config, messages, tools) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        resolve(this.completeChatUrl);
+      });
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getCompleteChatHeaders(config, messages, tools) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        resolve(this.getDefaultHeaders());
+      });
+    });
+  }
+  getCompleteChatData(config, messages, tools) {
+    return __async(this, null, function* () {
+      const transformedConfig = this.transformConfig(config, messages, tools);
+      const transformedMessages = this.transformMessages(messages);
+      if (transformedMessages.messages && transformedMessages.messages.length === 0) {
+        throw new import_provider.InvalidMessagesError({
+          info: "Messages are required",
+          cause: new Error("Messages are required")
+        });
+      }
+      const transformedTools = tools ? this.transformTools(tools) : {};
+      return new Promise((resolve) => {
+        resolve(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, this.getDefaultParams()), transformedConfig), transformedMessages), transformedTools));
+      });
+    });
+  }
+  transformCompleteChatResponse(response) {
+    const parsedResponse = XAICompleteChatResponse.safeParse(response);
+    if (!parsedResponse.success) {
+      throw new import_provider.ModelResponseError({ info: "Invalid response from model", cause: parsedResponse.error });
+    }
+    const data = parsedResponse.data;
+    const choice = data.choices[0];
+    const messages = [];
+    const assistantContent = [];
+    if (choice.message.content) {
+      assistantContent.push((0, import_types3.createTextContent)(choice.message.content));
+    }
+    if (choice.message.tool_calls) {
+      choice.message.tool_calls.forEach((toolCall, index) => {
+        assistantContent.push((0, import_types3.createToolCallContent)(index, toolCall.id, toolCall.function.name, toolCall.function.arguments));
+      });
+    }
+    if (assistantContent.length > 0) {
+      messages.push({ role: import_types3.AssistantRoleLiteral, content: assistantContent });
+    }
+    const usage = {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens,
+      totalTokens: data.usage.total_tokens
+    };
+    let logProbs2;
+    if (choice.logprobs && choice.logprobs.content) {
+      logProbs2 = choice.logprobs.content.map((logProb) => ({
+        token: logProb.token,
+        logProb: logProb.logprob,
+        bytes: logProb.bytes,
+        topLogProbs: logProb.top_logprobs.map((topLogProb) => ({
+          token: topLogProb.token,
+          logProb: topLogProb.logprob,
+          bytes: topLogProb.bytes
+        }))
+      }));
+    }
+    return {
+      messages,
+      usage,
+      logProbs: logProbs2
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getStreamChatUrl(config, messages, tools) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        resolve(this.streamChatUrl);
+      });
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getStreamChatHeaders(config, messages, tools) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        resolve(this.getDefaultHeaders());
+      });
+    });
+  }
+  getStreamChatData(config, messages, tools) {
+    return __async(this, null, function* () {
+      const transformedConfig = this.transformConfig(config, messages, tools);
+      const transformedMessages = this.transformMessages(messages);
+      if (transformedMessages.messages && transformedMessages.messages.length === 0) {
+        throw new import_provider.InvalidMessagesError({
+          info: "Messages are required",
+          cause: new Error("Messages are required")
+        });
+      }
+      const transformedTools = tools ? this.transformTools(tools) : {};
+      return new Promise((resolve) => {
+        resolve(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+          stream: true,
+          stream_options: { include_usage: true }
+        }, this.getDefaultParams()), transformedConfig), transformedMessages), transformedTools));
+      });
+    });
+  }
+  transformStreamChatResponseChunk(chunk, buffer) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b;
+      const data = buffer + chunk;
+      const lines = [];
+      let newBuffer = "";
+      let currentIndex = 0;
+      while (currentIndex < data.length) {
+        const newlineIndex = data.indexOf("\n", currentIndex);
+        if (newlineIndex === -1) {
+          newBuffer = data.substring(currentIndex);
+          break;
+        } else {
+          const line = data.substring(currentIndex, newlineIndex).trim();
+          if (line) {
+            lines.push(line);
+          }
+          currentIndex = newlineIndex + 1;
+        }
+      }
+      for (const line of lines) {
+        if (line === "data: [DONE]") {
+          return;
+        }
+        if (line.startsWith("data: ")) {
+          const jsonStr = line.substring("data: ".length);
+          try {
+            const structuredLine = JSON.parse(jsonStr);
+            const safe = XAIStreamChatResponse.safeParse(structuredLine);
+            if (safe.success) {
+              const partialResponse = { partialMessages: [] };
+              const parsedResponse = safe.data;
+              if (parsedResponse.choices.length > 0) {
+                const message = parsedResponse.choices[0].delta;
+                if (message !== void 0 && Object.keys(message).length !== 0) {
+                  if ("content" in message && message.content !== null) {
+                    partialResponse.partialMessages.push((0, import_types3.createPartialTextMessage)(import_types3.AssistantRoleLiteral, message.content));
+                  } else if ("tool_calls" in message && message.tool_calls !== void 0) {
+                    const toolCall = message.tool_calls.at(0);
+                    partialResponse.partialMessages.push(
+                      (0, import_types3.createPartialToolCallMessage)(
+                        import_types3.AssistantRoleLiteral,
+                        toolCall.index,
+                        toolCall.id,
+                        (_a = toolCall.function) == null ? void 0 : _a.name,
+                        (_b = toolCall.function) == null ? void 0 : _b.arguments
+                      )
+                    );
+                  }
+                }
+              }
+              if (parsedResponse.usage) {
+                partialResponse.usage = {
+                  promptTokens: parsedResponse.usage.prompt_tokens,
+                  completionTokens: parsedResponse.usage.completion_tokens,
+                  totalTokens: parsedResponse.usage.total_tokens
+                };
+              }
+              yield { partialResponse, buffer: newBuffer };
+            } else {
+              throw new import_provider.ModelResponseError({ info: "Invalid response from model", cause: safe.error });
+            }
+          } catch (error) {
+            throw new import_provider.ModelResponseError({
+              info: `Malformed JSON received in stream: ${jsonStr}`,
+              cause: error
+            });
+          }
+        }
+      }
+      yield { partialResponse: { partialMessages: [] }, buffer: newBuffer };
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  transformProxyStreamChatResponseChunk(chunk, buffer, data, headers, query) {
+    return __asyncGenerator(this, null, function* () {
+      yield* __yieldStar(this.transformStreamChatResponseChunk(chunk, buffer));
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getProxyStreamChatUrl(data, headers, query) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        resolve(this.streamChatUrl);
+      });
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getProxyCompleteChatUrl(data, headers, query) {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        resolve(this.completeChatUrl);
+      });
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getProxyCompleteChatHeaders(data, headers, query) {
+    return __async(this, null, function* () {
+      if (!headers) {
+        return {};
+      }
+      const sanitizedHeaders = __spreadValues({}, headers);
+      delete sanitizedHeaders.host;
+      delete sanitizedHeaders["content-length"];
+      return sanitizedHeaders;
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getProxyStreamChatHeaders(data, headers, query) {
+    return __async(this, null, function* () {
+      return yield this.getProxyCompleteChatHeaders(data, headers, query);
+    });
+  }
+  getModelPricing() {
+    if (!(this.modelName in pricing_default)) {
+      throw new import_provider.ModelResponseError({
+        info: `Invalid model pricing for model : '${this.modelName}'`,
+        cause: new Error(`No pricing configuration found for model "${this.modelName}"`)
+      });
+    }
+    const entry = pricing_default[this.modelName];
+    return entry;
+  }
+};
+
+// src/models/chat-models/grok-2.xai.ts
+var import_provider5 = require("@adaline/provider");
+
+// src/configs/chat-model/index.ts
+var chat_model_exports = {};
+__export(chat_model_exports, {
+  ChatModelBaseConfigDef: () => ChatModelBaseConfigDef,
+  ChatModelBaseConfigSchema: () => ChatModelBaseConfigSchema,
+  ChatModelMiniReasoningConfigDef: () => ChatModelMiniReasoningConfigDef,
+  ChatModelMiniReasoningConfigSchema: () => ChatModelMiniReasoningConfigSchema,
+  ChatModelReasoningConfigDef: () => ChatModelReasoningConfigDef,
+  ChatModelReasoningConfigSchema: () => ChatModelReasoningConfigSchema,
+  ChatModelResponseSchemaConfigDef: () => ChatModelResponseSchemaConfigDef,
+  ChatModelResponseSchemaConfigSchema: () => ChatModelResponseSchemaConfigSchema,
+  frequencyPenalty: () => frequencyPenalty,
+  logProbs: () => logProbs,
+  maxTokens: () => maxTokens,
+  presencePenalty: () => presencePenalty,
+  reasoningEffort: () => reasoningEffort,
+  seed: () => seed,
+  stop: () => stop,
+  temperature: () => temperature,
+  toolChoice: () => toolChoice,
+  topLogProbs: () => topLogProbs,
+  topP: () => topP
+});
+
+// src/configs/chat-model/base.config.chat-model.xai.ts
+var import_zod6 = require("zod");
+
+// src/configs/chat-model/common.config.chat-model.xai.ts
+var import_provider3 = require("@adaline/provider");
+var temperature = (0, import_provider3.RangeConfigItem)({
+  param: "temperature",
+  title: import_provider3.CHAT_CONFIG.TEMPERATURE.title,
+  description: import_provider3.CHAT_CONFIG.TEMPERATURE.description,
+  min: 0,
+  max: 2,
+  step: 0.01,
+  default: 1
+});
+var maxTokens = (maxOutputTokens) => (0, import_provider3.RangeConfigItem)({
+  param: "max_tokens",
+  title: import_provider3.CHAT_CONFIG.MAX_TOKENS.title,
+  description: import_provider3.CHAT_CONFIG.MAX_TOKENS.description,
+  min: 0,
+  max: maxOutputTokens,
+  step: 1,
+  default: 0
+});
+var stop = (maxSequences) => (0, import_provider3.MultiStringConfigItem)({
+  param: "stop",
+  title: import_provider3.CHAT_CONFIG.STOP(maxSequences).title,
+  description: import_provider3.CHAT_CONFIG.STOP(maxSequences).description,
+  max: maxSequences
+});
+var topP = (0, import_provider3.RangeConfigItem)({
+  param: "top_p",
+  title: import_provider3.CHAT_CONFIG.TOP_P.title,
+  description: import_provider3.CHAT_CONFIG.TOP_P.description,
+  min: 0,
+  max: 1,
+  step: 0.01,
+  default: 1
+});
+var frequencyPenalty = (0, import_provider3.RangeConfigItem)({
+  param: "frequency_penalty",
+  title: import_provider3.CHAT_CONFIG.FREQUENCY_PENALTY.title,
+  description: import_provider3.CHAT_CONFIG.FREQUENCY_PENALTY.description,
+  min: -2,
+  max: 2,
+  step: 0.01,
+  default: 0
+});
+var presencePenalty = (0, import_provider3.RangeConfigItem)({
+  param: "presence_penalty",
+  title: import_provider3.CHAT_CONFIG.PRESENCE_PENALTY.title,
+  description: import_provider3.CHAT_CONFIG.PRESENCE_PENALTY.description,
+  min: -2,
+  max: 2,
+  step: 0.01,
+  default: 0
+});
+var seed = (0, import_provider3.RangeConfigItem)({
+  param: "seed",
+  title: import_provider3.CHAT_CONFIG.SEED.title,
+  description: import_provider3.CHAT_CONFIG.SEED.description,
+  min: 0,
+  max: 1e6,
+  step: 1,
+  default: 0
+});
+var logProbs = (0, import_provider3.SelectBooleanConfigItem)({
+  param: "logprobs",
+  title: import_provider3.CHAT_CONFIG.LOG_PROBS.title,
+  description: import_provider3.CHAT_CONFIG.LOG_PROBS.description,
+  default: false
+});
+var topLogProbs = (0, import_provider3.RangeConfigItem)({
+  param: "top_logprobs",
+  title: import_provider3.CHAT_CONFIG.TOP_LOG_PROBS.title,
+  description: import_provider3.CHAT_CONFIG.TOP_LOG_PROBS.description,
+  min: 0,
+  max: 20,
+  step: 1,
+  default: 0
+});
+var toolChoice = (0, import_provider3.SelectStringConfigItem)({
+  param: "tool_choice",
+  title: "Tool choice",
+  description: "Controls which (if any) tool is called by the model. 'none' means the model will not call a function. 'auto' means the model can pick between generating a message or calling a tool.",
+  default: "auto",
+  choices: ["auto", "required", "none"]
+});
+var reasoningEffort = (0, import_provider3.SelectStringConfigItem)({
+  param: "reasoning_effort",
+  title: "Reasoning Effort",
+  description: "Controls how much time the model spends thinking before responding. 'low' uses minimal thinking time for quick responses, 'high' uses maximum thinking time for complex problems. Only supported by grok-3-mini models.",
+  default: "low",
+  choices: ["low", "high"]
+});
+
+// src/configs/chat-model/base.config.chat-model.xai.ts
+var ChatModelBaseConfigSchema = (maxOutputTokens, maxSequences) => import_zod6.z.object({
+  temperature: temperature.schema,
+  maxTokens: maxTokens(maxOutputTokens).schema,
+  stop: stop(maxSequences).schema,
+  topP: topP.schema,
+  frequencyPenalty: frequencyPenalty.schema,
+  presencePenalty: presencePenalty.schema,
+  seed: seed.schema.transform((value) => value === 0 ? void 0 : value),
+  logProbs: logProbs.schema,
+  topLogProbs: topLogProbs.schema,
+  toolChoice: toolChoice.schema
+});
+var ChatModelBaseConfigDef = (maxOutputTokens, maxSequences) => ({
+  temperature: temperature.def,
+  maxTokens: maxTokens(maxOutputTokens).def,
+  stop: stop(maxSequences).def,
+  topP: topP.def,
+  frequencyPenalty: frequencyPenalty.def,
+  presencePenalty: presencePenalty.def,
+  seed: seed.def,
+  logProbs: logProbs.def,
+  topLogProbs: topLogProbs.def,
+  toolChoice: toolChoice.def
+});
+
+// src/configs/chat-model/reasoning.config.chat-model.xai.ts
+var import_zod7 = require("zod");
+var ChatModelReasoningConfigSchema = (maxOutputTokens) => import_zod7.z.object({
+  temperature: temperature.schema,
+  maxTokens: maxTokens(maxOutputTokens).schema,
+  topP: topP.schema,
+  seed: seed.schema.transform((value) => value === 0 ? void 0 : value),
+  logProbs: logProbs.schema,
+  topLogProbs: topLogProbs.schema,
+  toolChoice: toolChoice.schema
+});
+var ChatModelReasoningConfigDef = (maxOutputTokens) => ({
+  temperature: temperature.def,
+  maxTokens: maxTokens(maxOutputTokens).def,
+  topP: topP.def,
+  seed: seed.def,
+  logProbs: logProbs.def,
+  topLogProbs: topLogProbs.def,
+  toolChoice: toolChoice.def
+});
+var ChatModelMiniReasoningConfigSchema = (maxOutputTokens, _maxSequences) => import_zod7.z.object({
+  temperature: temperature.schema,
+  maxTokens: maxTokens(maxOutputTokens).schema,
+  topP: topP.schema,
+  seed: seed.schema.transform((value) => value === 0 ? void 0 : value),
+  logProbs: logProbs.schema,
+  topLogProbs: topLogProbs.schema,
+  toolChoice: toolChoice.schema,
+  reasoningEffort: reasoningEffort.schema
+});
+var ChatModelMiniReasoningConfigDef = (maxOutputTokens) => ({
+  temperature: temperature.def,
+  maxTokens: maxTokens(maxOutputTokens).def,
+  topP: topP.def,
+  seed: seed.def,
+  logProbs: logProbs.def,
+  topLogProbs: topLogProbs.def,
+  toolChoice: toolChoice.def,
+  reasoningEffort: reasoningEffort.def
+});
+
+// src/configs/chat-model/response-schema.config.chat-model.xai.ts
+var import_provider4 = require("@adaline/provider");
+var import_types5 = require("@adaline/types");
+var responseSchema = (0, import_provider4.ObjectSchemaConfigItem)({
+  param: "response_schema",
+  title: import_provider4.CHAT_CONFIG.RESPONSE_SCHEMA.title,
+  description: import_provider4.CHAT_CONFIG.RESPONSE_SCHEMA.description,
+  objectSchema: import_types5.ResponseSchema
+});
+var responseFormat = (0, import_provider4.SelectStringConfigItem)({
+  param: "response_format",
+  title: import_provider4.CHAT_CONFIG.RESPONSE_FORMAT_WITH_SCHEMA.title,
+  description: import_provider4.CHAT_CONFIG.RESPONSE_FORMAT_WITH_SCHEMA.description,
+  default: "text",
+  choices: ["text", "json_object", "json_schema"]
+});
+var ChatModelResponseSchemaConfigDef = (maxOutputTokens, maxSequences) => __spreadProps(__spreadValues({}, ChatModelBaseConfigDef(maxOutputTokens, maxSequences)), {
+  responseFormat: responseFormat.def,
+  responseSchema: responseSchema.def
+});
+var ChatModelResponseSchemaConfigSchema = (maxOutputTokens, maxSequences) => ChatModelBaseConfigSchema(maxOutputTokens, maxSequences).extend({
+  responseFormat: responseFormat.schema,
+  responseSchema: responseSchema.schema
+});
+
+// src/models/chat-models/grok-2.xai.ts
+var Grok_2_Literal = "grok-2";
+var Grok_2_Description = "Grok-2 is xAI's flagship language model with strong reasoning capabilities and a 131K context window.";
+var Grok_2_Schema = (0, import_provider5.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_2_Literal,
+  description: Grok_2_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 32768,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(32768, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(32768, 4)
+  },
+  price: pricing_default[Grok_2_Literal]
+});
+var Grok_2_Options = BaseChatModelOptions;
+var Grok_2 = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_2_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-2-latest.xai.ts
+var import_provider6 = require("@adaline/provider");
+var Grok_2_Latest_Literal = "grok-2-latest";
+var Grok_2_Latest_Description = "Grok-2 Latest is the most recent version of xAI's Grok-2 model with a 131K context window.";
+var Grok_2_Latest_Schema = (0, import_provider6.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_2_Latest_Literal,
+  description: Grok_2_Latest_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 32768,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(32768, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(32768, 4)
+  },
+  price: pricing_default[Grok_2_Latest_Literal]
+});
+var Grok_2_Latest_Options = BaseChatModelOptions;
+var Grok_2_Latest = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_2_Latest_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-2-1212.xai.ts
+var import_provider7 = require("@adaline/provider");
+var Grok_2_1212_Literal = "grok-2-1212";
+var Grok_2_1212_Description = "Grok-2 version 1212 is a specific release of xAI's Grok-2 model with a 131K context window.";
+var Grok_2_1212_Schema = (0, import_provider7.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_2_1212_Literal,
+  description: Grok_2_1212_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 32768,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(32768, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(32768, 4)
+  },
+  price: pricing_default[Grok_2_1212_Literal]
+});
+var Grok_2_1212_Options = BaseChatModelOptions;
+var Grok_2_1212 = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_2_1212_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-3-beta.xai.ts
+var import_provider8 = require("@adaline/provider");
+var Grok_3_Beta_Literal = "grok-3-beta";
+var Grok_3_Beta_Description = "Grok-3 Beta is xAI's latest flagship model for enterprise tasks with a 131K context window.";
+var Grok_3_Beta_Schema = (0, import_provider8.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_3_Beta_Literal,
+  description: Grok_3_Beta_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(131072, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(131072, 4)
+  },
+  price: pricing_default[Grok_3_Beta_Literal]
+});
+var Grok_3_Beta_Options = BaseChatModelOptions;
+var Grok_3_Beta = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_3_Beta_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-3-fast-beta.xai.ts
+var import_provider9 = require("@adaline/provider");
+var Grok_3_Fast_Beta_Literal = "grok-3-fast-beta";
+var Grok_3_Fast_Beta_Description = "Grok-3 Fast Beta is xAI's fastest flagship model optimized for speed with a 131K context window.";
+var Grok_3_Fast_Beta_Schema = (0, import_provider9.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_3_Fast_Beta_Literal,
+  description: Grok_3_Fast_Beta_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(131072, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(131072, 4)
+  },
+  price: pricing_default[Grok_3_Fast_Beta_Literal]
+});
+var Grok_3_Fast_Beta_Options = BaseChatModelOptions;
+var Grok_3_Fast_Beta = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_3_Fast_Beta_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-3-mini-beta.xai.ts
+var import_provider10 = require("@adaline/provider");
+var Grok_3_Mini_Beta_Literal = "grok-3-mini-beta";
+var Grok_3_Mini_Beta_Description = "Grok-3 Mini Beta is xAI's lightweight reasoning model with support for reasoning_effort parameter and a 131K context window.";
+var Grok_3_Mini_Beta_Schema = (0, import_provider10.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_3_Mini_Beta_Literal,
+  description: Grok_3_Mini_Beta_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelMiniReasoningConfigDef(131072),
+    schema: chat_model_exports.ChatModelMiniReasoningConfigSchema(131072, 4)
+  },
+  price: pricing_default[Grok_3_Mini_Beta_Literal]
+});
+var Grok_3_Mini_Beta_Options = BaseChatModelOptions;
+var Grok_3_Mini_Beta = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_3_Mini_Beta_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-3-mini-fast-beta.xai.ts
+var import_provider11 = require("@adaline/provider");
+var Grok_3_Mini_Fast_Beta_Literal = "grok-3-mini-fast-beta";
+var Grok_3_Mini_Fast_Beta_Description = "Grok-3 Mini Fast Beta is xAI's fast lightweight model optimized for speed with a 131K context window.";
+var Grok_3_Mini_Fast_Beta_Schema = (0, import_provider11.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_3_Mini_Fast_Beta_Literal,
+  description: Grok_3_Mini_Fast_Beta_Description,
+  maxInputTokens: 131072,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(131072, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(131072, 4)
+  },
+  price: pricing_default[Grok_3_Mini_Fast_Beta_Literal]
+});
+var Grok_3_Mini_Fast_Beta_Options = BaseChatModelOptions;
+var Grok_3_Mini_Fast_Beta = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_3_Mini_Fast_Beta_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-4.xai.ts
+var import_provider12 = require("@adaline/provider");
+var Grok_4_Literal = "grok-4";
+var Grok_4_Description = "Grok-4 is xAI's most advanced reasoning model with a 256K context window.";
+var Grok_4_Schema = (0, import_provider12.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_4_Literal,
+  description: Grok_4_Description,
+  maxInputTokens: 262144,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelReasoningConfigDef(131072),
+    schema: chat_model_exports.ChatModelReasoningConfigSchema(131072)
+  },
+  price: pricing_default[Grok_4_Literal]
+});
+var Grok_4_Options = BaseChatModelOptions;
+var Grok_4 = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_4_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-4-0709.xai.ts
+var import_provider13 = require("@adaline/provider");
+var Grok_4_0709_Literal = "grok-4-0709";
+var Grok_4_0709_Description = "Grok-4 version 0709 is a specific release of xAI's most advanced reasoning model with a 256K context window.";
+var Grok_4_0709_Schema = (0, import_provider13.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_4_0709_Literal,
+  description: Grok_4_0709_Description,
+  maxInputTokens: 262144,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelReasoningConfigDef(131072),
+    schema: chat_model_exports.ChatModelReasoningConfigSchema(131072)
+  },
+  price: pricing_default[Grok_4_0709_Literal]
+});
+var Grok_4_0709_Options = BaseChatModelOptions;
+var Grok_4_0709 = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_4_0709_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-4-fast-reasoning.xai.ts
+var import_provider14 = require("@adaline/provider");
+var Grok_4_Fast_Reasoning_Literal = "grok-4-fast-reasoning";
+var Grok_4_Fast_Reasoning_Description = "Grok-4 Fast Reasoning is xAI's fast reasoning model with a 2M context window.";
+var Grok_4_Fast_Reasoning_Schema = (0, import_provider14.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_4_Fast_Reasoning_Literal,
+  description: Grok_4_Fast_Reasoning_Description,
+  maxInputTokens: 2097152,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelReasoningConfigDef(131072),
+    schema: chat_model_exports.ChatModelReasoningConfigSchema(131072)
+  },
+  price: pricing_default[Grok_4_Fast_Reasoning_Literal]
+});
+var Grok_4_Fast_Reasoning_Options = BaseChatModelOptions;
+var Grok_4_Fast_Reasoning = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_4_Fast_Reasoning_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-4-fast-non-reasoning.xai.ts
+var import_provider15 = require("@adaline/provider");
+var Grok_4_Fast_Non_Reasoning_Literal = "grok-4-fast-non-reasoning";
+var Grok_4_Fast_Non_Reasoning_Description = "Grok-4 Fast Non-Reasoning is xAI's fast model without reasoning capabilities with a 2M context window.";
+var Grok_4_Fast_Non_Reasoning_Schema = (0, import_provider15.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_4_Fast_Non_Reasoning_Literal,
+  description: Grok_4_Fast_Non_Reasoning_Description,
+  maxInputTokens: 2097152,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(131072, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(131072, 4)
+  },
+  price: pricing_default[Grok_4_Fast_Non_Reasoning_Literal]
+});
+var Grok_4_Fast_Non_Reasoning_Options = BaseChatModelOptions;
+var Grok_4_Fast_Non_Reasoning = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_4_Fast_Non_Reasoning_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-4.1-fast-reasoning.xai.ts
+var import_provider16 = require("@adaline/provider");
+var Grok_4_1_Fast_Reasoning_Literal = "grok-4.1-fast-reasoning";
+var Grok_4_1_Fast_Reasoning_Description = "Grok-4.1 Fast Reasoning is xAI's updated fast reasoning model with a 2M context window.";
+var Grok_4_1_Fast_Reasoning_Schema = (0, import_provider16.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_4_1_Fast_Reasoning_Literal,
+  description: Grok_4_1_Fast_Reasoning_Description,
+  maxInputTokens: 2097152,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelReasoningConfigDef(131072),
+    schema: chat_model_exports.ChatModelReasoningConfigSchema(131072)
+  },
+  price: pricing_default["grok-4.1-fast-reasoning"]
+});
+var Grok_4_1_Fast_Reasoning_Options = BaseChatModelOptions;
+var Grok_4_1_Fast_Reasoning = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_4_1_Fast_Reasoning_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-4.1-fast-non-reasoning.xai.ts
+var import_provider17 = require("@adaline/provider");
+var Grok_4_1_Fast_Non_Reasoning_Literal = "grok-4.1-fast-non-reasoning";
+var Grok_4_1_Fast_Non_Reasoning_Description = "Grok-4.1 Fast Non-Reasoning is xAI's updated fast model without reasoning capabilities with a 2M context window.";
+var Grok_4_1_Fast_Non_Reasoning_Schema = (0, import_provider17.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_4_1_Fast_Non_Reasoning_Literal,
+  description: Grok_4_1_Fast_Non_Reasoning_Description,
+  maxInputTokens: 2097152,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(131072, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(131072, 4)
+  },
+  price: pricing_default["grok-4.1-fast-non-reasoning"]
+});
+var Grok_4_1_Fast_Non_Reasoning_Options = BaseChatModelOptions;
+var Grok_4_1_Fast_Non_Reasoning = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_4_1_Fast_Non_Reasoning_Schema, options);
+  }
+};
+
+// src/models/chat-models/grok-code-fast-1.xai.ts
+var import_provider18 = require("@adaline/provider");
+var Grok_Code_Fast_1_Literal = "grok-code-fast-1";
+var Grok_Code_Fast_1_Description = "Grok Code Fast 1 is xAI's specialized coding model optimized for code generation with a 256K context window.";
+var Grok_Code_Fast_1_Schema = (0, import_provider18.ChatModelSchema)(XAIChatModelRoles, XAIChatModelTextToolModalitiesEnum).parse({
+  name: Grok_Code_Fast_1_Literal,
+  description: Grok_Code_Fast_1_Description,
+  maxInputTokens: 262144,
+  maxOutputTokens: 131072,
+  roles: XAIChatModelRolesMap,
+  modalities: XAIChatModelTextToolModalities,
+  config: {
+    def: chat_model_exports.ChatModelResponseSchemaConfigDef(131072, 4),
+    schema: chat_model_exports.ChatModelResponseSchemaConfigSchema(131072, 4)
+  },
+  price: pricing_default[Grok_Code_Fast_1_Literal]
+});
+var Grok_Code_Fast_1_Options = BaseChatModelOptions;
+var Grok_Code_Fast_1 = class extends BaseChatModel {
+  constructor(options) {
+    super(Grok_Code_Fast_1_Schema, options);
+  }
+};
+
+// src/provider/provider.xai.ts
+var ProviderLiteral = "xai";
+var XAI = class {
+  constructor() {
+    this.version = "v1";
+    this.name = ProviderLiteral;
+    this.chatModelFactories = {
+      [Grok_2_Literal]: {
+        model: Grok_2,
+        modelOptions: Grok_2_Options,
+        modelSchema: Grok_2_Schema
+      },
+      [Grok_2_Latest_Literal]: {
+        model: Grok_2_Latest,
+        modelOptions: Grok_2_Latest_Options,
+        modelSchema: Grok_2_Latest_Schema
+      },
+      [Grok_2_1212_Literal]: {
+        model: Grok_2_1212,
+        modelOptions: Grok_2_1212_Options,
+        modelSchema: Grok_2_1212_Schema
+      },
+      [Grok_3_Beta_Literal]: {
+        model: Grok_3_Beta,
+        modelOptions: Grok_3_Beta_Options,
+        modelSchema: Grok_3_Beta_Schema
+      },
+      [Grok_3_Fast_Beta_Literal]: {
+        model: Grok_3_Fast_Beta,
+        modelOptions: Grok_3_Fast_Beta_Options,
+        modelSchema: Grok_3_Fast_Beta_Schema
+      },
+      [Grok_3_Mini_Beta_Literal]: {
+        model: Grok_3_Mini_Beta,
+        modelOptions: Grok_3_Mini_Beta_Options,
+        modelSchema: Grok_3_Mini_Beta_Schema
+      },
+      [Grok_3_Mini_Fast_Beta_Literal]: {
+        model: Grok_3_Mini_Fast_Beta,
+        modelOptions: Grok_3_Mini_Fast_Beta_Options,
+        modelSchema: Grok_3_Mini_Fast_Beta_Schema
+      },
+      [Grok_4_Literal]: {
+        model: Grok_4,
+        modelOptions: Grok_4_Options,
+        modelSchema: Grok_4_Schema
+      },
+      [Grok_4_0709_Literal]: {
+        model: Grok_4_0709,
+        modelOptions: Grok_4_0709_Options,
+        modelSchema: Grok_4_0709_Schema
+      },
+      [Grok_4_Fast_Reasoning_Literal]: {
+        model: Grok_4_Fast_Reasoning,
+        modelOptions: Grok_4_Fast_Reasoning_Options,
+        modelSchema: Grok_4_Fast_Reasoning_Schema
+      },
+      [Grok_4_Fast_Non_Reasoning_Literal]: {
+        model: Grok_4_Fast_Non_Reasoning,
+        modelOptions: Grok_4_Fast_Non_Reasoning_Options,
+        modelSchema: Grok_4_Fast_Non_Reasoning_Schema
+      },
+      [Grok_4_1_Fast_Reasoning_Literal]: {
+        model: Grok_4_1_Fast_Reasoning,
+        modelOptions: Grok_4_1_Fast_Reasoning_Options,
+        modelSchema: Grok_4_1_Fast_Reasoning_Schema
+      },
+      [Grok_4_1_Fast_Non_Reasoning_Literal]: {
+        model: Grok_4_1_Fast_Non_Reasoning,
+        modelOptions: Grok_4_1_Fast_Non_Reasoning_Options,
+        modelSchema: Grok_4_1_Fast_Non_Reasoning_Schema
+      },
+      [Grok_Code_Fast_1_Literal]: {
+        model: Grok_Code_Fast_1,
+        modelOptions: Grok_Code_Fast_1_Options,
+        modelSchema: Grok_Code_Fast_1_Schema
+      }
+    };
+  }
+  chatModelLiterals() {
+    return Object.keys(this.chatModelFactories);
+  }
+  chatModelSchemas() {
+    return Object.keys(this.chatModelFactories).reduce(
+      (acc, key) => {
+        acc[key] = this.chatModelFactories[key].modelSchema;
+        return acc;
+      },
+      {}
+    );
+  }
+  chatModel(options) {
+    const modelName = options.modelName;
+    const factory = this.chatModelFactories[modelName];
+    if (!factory) {
+      throw new import_provider19.ProviderError({
+        info: `Invalid model name: '${modelName}' for provider: '${this.name}'`,
+        cause: new Error(`Available models: [${this.chatModelLiterals().join(", ")}]`)
+      });
+    }
+    const parsedOptions = factory.modelOptions.parse(options);
+    return new factory.model(parsedOptions);
+  }
+  // XAI does not support embedding models
+  embeddingModelLiterals() {
+    return [];
+  }
+  embeddingModelSchemas() {
+    return {};
+  }
+  embeddingModel() {
+    throw new import_provider19.ProviderError({
+      info: "XAI does not support embedding models",
+      cause: new Error("No embedding models available")
+    });
+  }
+};
+XAI.baseUrl = "https://api.x.ai/v1";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseChatModel,
+  BaseChatModelOptions,
+  Grok_2,
+  Grok_2_1212,
+  Grok_2_1212_Literal,
+  Grok_2_1212_Options,
+  Grok_2_1212_Schema,
+  Grok_2_Latest,
+  Grok_2_Latest_Literal,
+  Grok_2_Latest_Options,
+  Grok_2_Latest_Schema,
+  Grok_2_Literal,
+  Grok_2_Options,
+  Grok_2_Schema,
+  Grok_3_Beta,
+  Grok_3_Beta_Literal,
+  Grok_3_Beta_Options,
+  Grok_3_Beta_Schema,
+  Grok_3_Fast_Beta,
+  Grok_3_Fast_Beta_Literal,
+  Grok_3_Fast_Beta_Options,
+  Grok_3_Fast_Beta_Schema,
+  Grok_3_Mini_Beta,
+  Grok_3_Mini_Beta_Literal,
+  Grok_3_Mini_Beta_Options,
+  Grok_3_Mini_Beta_Schema,
+  Grok_3_Mini_Fast_Beta,
+  Grok_3_Mini_Fast_Beta_Literal,
+  Grok_3_Mini_Fast_Beta_Options,
+  Grok_3_Mini_Fast_Beta_Schema,
+  Grok_4,
+  Grok_4_0709,
+  Grok_4_0709_Literal,
+  Grok_4_0709_Options,
+  Grok_4_0709_Schema,
+  Grok_4_1_Fast_Non_Reasoning,
+  Grok_4_1_Fast_Non_Reasoning_Literal,
+  Grok_4_1_Fast_Non_Reasoning_Options,
+  Grok_4_1_Fast_Non_Reasoning_Schema,
+  Grok_4_1_Fast_Reasoning,
+  Grok_4_1_Fast_Reasoning_Literal,
+  Grok_4_1_Fast_Reasoning_Options,
+  Grok_4_1_Fast_Reasoning_Schema,
+  Grok_4_Fast_Non_Reasoning,
+  Grok_4_Fast_Non_Reasoning_Literal,
+  Grok_4_Fast_Non_Reasoning_Options,
+  Grok_4_Fast_Non_Reasoning_Schema,
+  Grok_4_Fast_Reasoning,
+  Grok_4_Fast_Reasoning_Literal,
+  Grok_4_Fast_Reasoning_Options,
+  Grok_4_Fast_Reasoning_Schema,
+  Grok_4_Literal,
+  Grok_4_Options,
+  Grok_4_Schema,
+  Grok_Code_Fast_1,
+  Grok_Code_Fast_1_Literal,
+  Grok_Code_Fast_1_Options,
+  Grok_Code_Fast_1_Schema,
+  ProviderLiteral,
+  XAI,
+  XAIChatModelConfigs,
+  XAIChatModelModalities,
+  XAIChatModelModalitiesEnum,
+  XAIChatModelRoles,
+  XAIChatModelRolesMap,
+  XAIChatModelTextModalities,
+  XAIChatModelTextModalitiesEnum,
+  XAIChatModelTextToolModalities,
+  XAIChatModelTextToolModalitiesEnum,
+  XAIChatRequest,
+  XAIChatRequestAssistantMessage,
+  XAIChatRequestImageContent,
+  XAIChatRequestMessage,
+  XAIChatRequestResponseFormat,
+  XAIChatRequestSystemMessage,
+  XAIChatRequestTextContent,
+  XAIChatRequestTool,
+  XAIChatRequestToolCallContent,
+  XAIChatRequestToolChoiceEnum,
+  XAIChatRequestToolChoiceFunction,
+  XAIChatRequestToolMessage,
+  XAIChatRequestUserMessage,
+  XAICompleteChatResponse,
+  XAIStreamChatResponse,
+  XAIToolCallsCompleteChatResponse,
+  XAIToolCallsStreamChatResponse
+});
+//# sourceMappingURL=index.js.map