@providerprotocol/ai 0.0.4 → 0.0.5

package/dist/xai/index.js

@@ -0,0 +1,1812 @@
+import {
+  AssistantMessage,
+  isAssistantMessage,
+  isToolResultMessage,
+  isUserMessage
+} from "../chunk-QUUX4G7U.js";
+import {
+  parseSSEStream
+} from "../chunk-X5G4EHL7.js";
+import {
+  UPPError,
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError,
+  resolveApiKey
+} from "../chunk-SUNYWHTH.js";
+
+// src/providers/xai/transform.completions.ts
+function transformRequest(request, modelId) {
+  const params = request.params ?? {};
+  const xaiRequest = {
+    model: modelId,
+    messages: transformMessages(request.messages, request.system)
+  };
+  if (params.temperature !== void 0) {
+    xaiRequest.temperature = params.temperature;
+  }
+  if (params.top_p !== void 0) {
+    xaiRequest.top_p = params.top_p;
+  }
+  if (params.max_completion_tokens !== void 0) {
+    xaiRequest.max_completion_tokens = params.max_completion_tokens;
+  } else if (params.max_tokens !== void 0) {
+    xaiRequest.max_tokens = params.max_tokens;
+  }
+  if (params.frequency_penalty !== void 0) {
+    xaiRequest.frequency_penalty = params.frequency_penalty;
+  }
+  if (params.presence_penalty !== void 0) {
+    xaiRequest.presence_penalty = params.presence_penalty;
+  }
+  if (params.stop !== void 0) {
+    xaiRequest.stop = params.stop;
+  }
+  if (params.n !== void 0) {
+    xaiRequest.n = params.n;
+  }
+  if (params.logprobs !== void 0) {
+    xaiRequest.logprobs = params.logprobs;
+  }
+  if (params.top_logprobs !== void 0) {
+    xaiRequest.top_logprobs = params.top_logprobs;
+  }
+  if (params.seed !== void 0) {
+    xaiRequest.seed = params.seed;
+  }
+  if (params.user !== void 0) {
+    xaiRequest.user = params.user;
+  }
+  if (params.logit_bias !== void 0) {
+    xaiRequest.logit_bias = params.logit_bias;
+  }
+  if (params.reasoning_effort !== void 0) {
+    xaiRequest.reasoning_effort = params.reasoning_effort;
+  }
+  if (params.store !== void 0) {
+    xaiRequest.store = params.store;
+  }
+  if (params.metadata !== void 0) {
+    xaiRequest.metadata = params.metadata;
+  }
+  if (params.search_parameters !== void 0) {
+    xaiRequest.search_parameters = params.search_parameters;
+  }
+  if (request.tools && request.tools.length > 0) {
+    xaiRequest.tools = request.tools.map(transformTool);
+    if (params.parallel_tool_calls !== void 0) {
+      xaiRequest.parallel_tool_calls = params.parallel_tool_calls;
+    }
+  }
+  if (request.structure) {
+    const schema = {
+      type: "object",
+      properties: request.structure.properties,
+      required: request.structure.required,
+      ...request.structure.additionalProperties !== void 0 ? { additionalProperties: request.structure.additionalProperties } : { additionalProperties: false }
+    };
+    if (request.structure.description) {
+      schema.description = request.structure.description;
+    }
+    xaiRequest.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: "json_response",
+        description: request.structure.description,
+        schema,
+        strict: true
+      }
+    };
+  } else if (params.response_format !== void 0) {
+    xaiRequest.response_format = params.response_format;
+  }
+  return xaiRequest;
+}
+function transformMessages(messages, system) {
+  const result = [];
+  if (system) {
+    result.push({
+      role: "system",
+      content: system
+    });
+  }
+  for (const message of messages) {
+    if (isToolResultMessage(message)) {
+      const toolMessages = transformToolResults(message);
+      result.push(...toolMessages);
+    } else {
+      const transformed = transformMessage(message);
+      if (transformed) {
+        result.push(transformed);
+      }
+    }
+  }
+  return result;
+}
+function filterValidContent(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformMessage(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    if (validContent.length === 1 && validContent[0]?.type === "text") {
+      return {
+        role: "user",
+        content: validContent[0].text
+      };
+    }
+    return {
+      role: "user",
+      content: validContent.map(transformContentBlock)
+    };
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    const textContent = validContent.filter((c) => c.type === "text").map((c) => c.text).join("");
+    const hasToolCalls = message.toolCalls && message.toolCalls.length > 0;
+    const assistantMessage = {
+      role: "assistant",
+      // xAI/OpenAI: content should be null when tool_calls are present and there's no text
+      content: hasToolCalls && !textContent ? null : textContent
+    };
+    if (hasToolCalls) {
+      assistantMessage.tool_calls = message.toolCalls.map((call) => ({
+        id: call.toolCallId,
+        type: "function",
+        function: {
+          name: call.toolName,
+          arguments: JSON.stringify(call.arguments)
+        }
+      }));
+    }
+    return assistantMessage;
+  }
+  if (isToolResultMessage(message)) {
+    const results = message.results.map((result) => ({
+      role: "tool",
+      tool_call_id: result.toolCallId,
+      content: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+    }));
+    return results[0] ?? null;
+  }
+  return null;
+}
+function transformToolResults(message) {
+  if (!isToolResultMessage(message)) {
+    const single = transformMessage(message);
+    return single ? [single] : [];
+  }
+  return message.results.map((result) => ({
+    role: "tool",
+    tool_call_id: result.toolCallId,
+    content: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+  }));
+}
+function transformContentBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "image": {
+      const imageBlock = block;
+      let url;
+      if (imageBlock.source.type === "base64") {
+        url = `data:${imageBlock.mimeType};base64,${imageBlock.source.data}`;
+      } else if (imageBlock.source.type === "url") {
+        url = imageBlock.source.url;
+      } else if (imageBlock.source.type === "bytes") {
+        const base64 = btoa(
+          Array.from(imageBlock.source.data).map((b) => String.fromCharCode(b)).join("")
+        );
+        url = `data:${imageBlock.mimeType};base64,${base64}`;
+      } else {
+        throw new Error("Unknown image source type");
+      }
+      return {
+        type: "image_url",
+        image_url: { url }
+      };
+    }
+    default:
+      throw new Error(`Unsupported content type: ${block.type}`);
+  }
+}
+function transformTool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: "object",
+        properties: tool.parameters.properties,
+        required: tool.parameters.required,
+        ...tool.parameters.additionalProperties !== void 0 ? { additionalProperties: tool.parameters.additionalProperties } : {}
+      }
+    }
+  };
+}
+function transformResponse(data) {
+  const choice = data.choices[0];
+  if (!choice) {
+    throw new Error("No choices in xAI response");
+  }
+  const textContent = [];
+  let structuredData;
+  if (choice.message.content) {
+    textContent.push({ type: "text", text: choice.message.content });
+    try {
+      structuredData = JSON.parse(choice.message.content);
+    } catch {
+    }
+  }
+  let hadRefusal = false;
+  if (choice.message.refusal) {
+    textContent.push({ type: "text", text: choice.message.refusal });
+    hadRefusal = true;
+  }
+  const toolCalls = [];
+  if (choice.message.tool_calls) {
+    for (const call of choice.message.tool_calls) {
+      let args = {};
+      try {
+        args = JSON.parse(call.function.arguments);
+      } catch {
+      }
+      toolCalls.push({
+        toolCallId: call.id,
+        toolName: call.function.name,
+        arguments: args
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: data.id,
+      metadata: {
+        xai: {
+          model: data.model,
+          finish_reason: choice.finish_reason,
+          system_fingerprint: data.system_fingerprint,
+          citations: data.citations,
+          inline_citations: data.inline_citations
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.prompt_tokens,
+    outputTokens: data.usage.completion_tokens,
+    totalTokens: data.usage.total_tokens
+  };
+  let stopReason = "end_turn";
+  switch (choice.finish_reason) {
+    case "stop":
+      stopReason = "end_turn";
+      break;
+    case "length":
+      stopReason = "max_tokens";
+      break;
+    case "tool_calls":
+      stopReason = "tool_use";
+      break;
+    case "content_filter":
+      stopReason = "content_filter";
+      break;
+  }
+  if (hadRefusal && stopReason !== "content_filter") {
+    stopReason = "content_filter";
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+function createStreamState() {
+  return {
+    id: "",
+    model: "",
+    text: "",
+    toolCalls: /* @__PURE__ */ new Map(),
+    finishReason: null,
+    inputTokens: 0,
+    outputTokens: 0,
+    hadRefusal: false
+  };
+}
+function transformStreamEvent(chunk, state) {
+  const events = [];
+  if (chunk.id && !state.id) {
+    state.id = chunk.id;
+    events.push({ type: "message_start", index: 0, delta: {} });
+  }
+  if (chunk.model) {
+    state.model = chunk.model;
+  }
+  const choice = chunk.choices[0];
+  if (choice) {
+    if (choice.delta.content) {
+      state.text += choice.delta.content;
+      events.push({
+        type: "text_delta",
+        index: 0,
+        delta: { text: choice.delta.content }
+      });
+    }
+    if (choice.delta.refusal) {
+      state.hadRefusal = true;
+      state.text += choice.delta.refusal;
+      events.push({
+        type: "text_delta",
+        index: 0,
+        delta: { text: choice.delta.refusal }
+      });
+    }
+    if (choice.delta.tool_calls) {
+      for (const toolCallDelta of choice.delta.tool_calls) {
+        const index = toolCallDelta.index;
+        let toolCall = state.toolCalls.get(index);
+        if (!toolCall) {
+          toolCall = { id: "", name: "", arguments: "" };
+          state.toolCalls.set(index, toolCall);
+        }
+        if (toolCallDelta.id) {
+          toolCall.id = toolCallDelta.id;
+        }
+        if (toolCallDelta.function?.name) {
+          toolCall.name = toolCallDelta.function.name;
+        }
+        if (toolCallDelta.function?.arguments) {
+          toolCall.arguments += toolCallDelta.function.arguments;
+          events.push({
+            type: "tool_call_delta",
+            index,
+            delta: {
+              toolCallId: toolCall.id,
+              toolName: toolCall.name,
+              argumentsJson: toolCallDelta.function.arguments
+            }
+          });
+        }
+      }
+    }
+    if (choice.finish_reason) {
+      state.finishReason = choice.finish_reason;
+      events.push({ type: "message_stop", index: 0, delta: {} });
+    }
+  }
+  if (chunk.usage) {
+    state.inputTokens = chunk.usage.prompt_tokens;
+    state.outputTokens = chunk.usage.completion_tokens;
+  }
+  return events;
+}
+function buildResponseFromState(state) {
+  const textContent = [];
+  let structuredData;
+  if (state.text) {
+    textContent.push({ type: "text", text: state.text });
+    try {
+      structuredData = JSON.parse(state.text);
+    } catch {
+    }
+  }
+  const toolCalls = [];
+  for (const [, toolCall] of state.toolCalls) {
+    let args = {};
+    if (toolCall.arguments) {
+      try {
+        args = JSON.parse(toolCall.arguments);
+      } catch {
+      }
+    }
+    toolCalls.push({
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      arguments: args
+    });
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: state.id,
+      metadata: {
+        xai: {
+          model: state.model,
+          finish_reason: state.finishReason
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens
+  };
+  let stopReason = "end_turn";
+  switch (state.finishReason) {
+    case "stop":
+      stopReason = "end_turn";
+      break;
+    case "length":
+      stopReason = "max_tokens";
+      break;
+    case "tool_calls":
+      stopReason = "tool_use";
+      break;
+    case "content_filter":
+      stopReason = "content_filter";
+      break;
+  }
+  if (state.hadRefusal && stopReason !== "content_filter") {
+    stopReason = "content_filter";
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+
+// src/providers/xai/llm.completions.ts
+var XAI_COMPLETIONS_API_URL = "https://api.x.ai/v1/chat/completions";
+var XAI_COMPLETIONS_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  videoInput: false,
+  audioInput: false
+};
+function createCompletionsLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider() or have _setProvider called.",
+          "INVALID_REQUEST",
+          "xai",
+          "llm"
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: XAI_COMPLETIONS_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const apiKey = await resolveApiKey(
+            request.config,
+            "XAI_API_KEY",
+            "xai",
+            "llm"
+          );
+          const baseUrl = request.config.baseUrl ?? XAI_COMPLETIONS_API_URL;
+          const body = transformRequest(request, modelId);
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`
+              },
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "xai",
+            "llm"
+          );
+          const data = await response.json();
+          return transformResponse(data);
+        },
+        stream(request) {
+          const state = createStreamState();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const apiKey = await resolveApiKey(
+                request.config,
+                "XAI_API_KEY",
+                "xai",
+                "llm"
+              );
+              const baseUrl = request.config.baseUrl ?? XAI_COMPLETIONS_API_URL;
+              const body = transformRequest(request, modelId);
+              body.stream = true;
+              body.stream_options = { include_usage: true };
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`
+                  },
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "xai",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "xai", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  "PROVIDER_ERROR",
+                  "xai",
+                  "llm"
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (data === "[DONE]") {
+                  continue;
+                }
+                if (typeof data === "object" && data !== null) {
+                  const chunk = data;
+                  if ("error" in chunk && chunk.error) {
+                    const errorData = chunk.error;
+                    const error = new UPPError(
+                      errorData.message ?? "Unknown error",
+                      "PROVIDER_ERROR",
+                      "xai",
+                      "llm"
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvents = transformStreamEvent(chunk, state);
+                  for (const event of uppEvents) {
+                    yield event;
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState(state));
+            } catch (error) {
+              responseReject(error);
+              throw error;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/xai/transform.responses.ts
+function transformRequest2(request, modelId) {
+  const params = request.params ?? {};
+  const xaiRequest = {
+    model: modelId,
+    input: transformInputItems(request.messages, request.system)
+  };
+  if (params.temperature !== void 0) {
+    xaiRequest.temperature = params.temperature;
+  }
+  if (params.top_p !== void 0) {
+    xaiRequest.top_p = params.top_p;
+  }
+  if (params.max_output_tokens !== void 0) {
+    xaiRequest.max_output_tokens = params.max_output_tokens;
+  } else if (params.max_completion_tokens !== void 0) {
+    xaiRequest.max_output_tokens = params.max_completion_tokens;
+  } else if (params.max_tokens !== void 0) {
+    xaiRequest.max_output_tokens = params.max_tokens;
+  }
+  if (params.store !== void 0) {
+    xaiRequest.store = params.store;
+  }
+  if (params.metadata !== void 0) {
+    xaiRequest.metadata = params.metadata;
+  }
+  if (params.truncation !== void 0) {
+    xaiRequest.truncation = params.truncation;
+  }
+  if (params.include !== void 0) {
+    xaiRequest.include = params.include;
+  }
+  if (params.previous_response_id !== void 0) {
+    xaiRequest.previous_response_id = params.previous_response_id;
+  }
+  if (params.reasoning !== void 0) {
+    xaiRequest.reasoning = { ...params.reasoning };
+  }
+  if (params.reasoning_effort !== void 0) {
+    xaiRequest.reasoning = {
+      ...xaiRequest.reasoning ?? {},
+      effort: params.reasoning_effort
+    };
+  }
+  if (params.search_parameters !== void 0) {
+    xaiRequest.search_parameters = params.search_parameters;
+  }
+  if (request.tools && request.tools.length > 0) {
+    xaiRequest.tools = request.tools.map(transformTool2);
+    if (params.parallel_tool_calls !== void 0) {
+      xaiRequest.parallel_tool_calls = params.parallel_tool_calls;
+    }
+  }
+  if (request.structure) {
+    const schema = {
+      type: "object",
+      properties: request.structure.properties,
+      required: request.structure.required,
+      ...request.structure.additionalProperties !== void 0 ? { additionalProperties: request.structure.additionalProperties } : { additionalProperties: false }
+    };
+    if (request.structure.description) {
+      schema.description = request.structure.description;
+    }
+    xaiRequest.text = {
+      format: {
+        type: "json_schema",
+        name: "json_response",
+        description: request.structure.description,
+        schema,
+        strict: true
+      }
+    };
+  }
+  return xaiRequest;
+}
+function transformInputItems(messages, system) {
+  const result = [];
+  if (system) {
+    result.push({
+      type: "message",
+      role: "system",
+      content: system
+    });
+  }
+  for (const message of messages) {
+    const items = transformMessage2(message);
+    result.push(...items);
+  }
+  if (result.length === 1 && result[0]?.type === "message") {
+    const item = result[0];
+    if (item.role === "user" && typeof item.content === "string") {
+      return item.content;
+    }
+  }
+  return result;
+}
+function filterValidContent2(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformMessage2(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent2(message.content);
+    if (validContent.length === 1 && validContent[0]?.type === "text") {
+      return [
+        {
+          type: "message",
+          role: "user",
+          content: validContent[0].text
+        }
+      ];
+    }
+    return [
+      {
+        type: "message",
+        role: "user",
+        content: validContent.map(transformContentPart)
+      }
+    ];
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent2(message.content);
+    const items = [];
+    const textContent = validContent.filter((c) => c.type === "text").map((c) => c.text).join("\n\n");
+    if (textContent) {
+      items.push({
+        type: "message",
+        role: "assistant",
+        content: textContent
+      });
+    }
+    const xaiMeta = message.metadata?.xai;
+    const functionCallItems = xaiMeta?.functionCallItems;
+    if (functionCallItems && functionCallItems.length > 0) {
+      for (const fc of functionCallItems) {
+        items.push({
+          type: "function_call",
+          id: fc.id,
+          call_id: fc.call_id,
+          name: fc.name,
+          arguments: fc.arguments
+        });
+      }
+    } else if (message.toolCalls && message.toolCalls.length > 0) {
+      for (const call of message.toolCalls) {
+        items.push({
+          type: "function_call",
+          id: `fc_${call.toolCallId}`,
+          call_id: call.toolCallId,
+          name: call.toolName,
+          arguments: JSON.stringify(call.arguments)
+        });
+      }
+    }
+    return items;
+  }
+  if (isToolResultMessage(message)) {
+    return message.results.map((result) => ({
+      type: "function_call_output",
+      call_id: result.toolCallId,
+      output: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+    }));
+  }
+  return [];
+}
+function transformContentPart(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "input_text", text: block.text };
+    case "image": {
+      const imageBlock = block;
+      if (imageBlock.source.type === "base64") {
+        return {
+          type: "input_image",
+          image_url: `data:${imageBlock.mimeType};base64,${imageBlock.source.data}`
+        };
+      }
+      if (imageBlock.source.type === "url") {
+        return {
+          type: "input_image",
+          image_url: imageBlock.source.url
+        };
+      }
+      if (imageBlock.source.type === "bytes") {
+        const base64 = btoa(
+          Array.from(imageBlock.source.data).map((b) => String.fromCharCode(b)).join("")
+        );
+        return {
+          type: "input_image",
+          image_url: `data:${imageBlock.mimeType};base64,${base64}`
+        };
+      }
+      throw new Error("Unknown image source type");
+    }
+    default:
+      throw new Error(`Unsupported content type: ${block.type}`);
+  }
+}
+function transformTool2(tool) {
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: {
+      type: "object",
+      properties: tool.parameters.properties,
+      required: tool.parameters.required,
+      ...tool.parameters.additionalProperties !== void 0 ? { additionalProperties: tool.parameters.additionalProperties } : {}
+    }
+  };
+}
+function transformResponse2(data) {
+  const textContent = [];
+  const toolCalls = [];
+  const functionCallItems = [];
+  let hadRefusal = false;
+  let structuredData;
+  for (const item of data.output) {
+    if (item.type === "message") {
+      const messageItem = item;
+      for (const content of messageItem.content) {
+        if (content.type === "output_text") {
+          textContent.push({ type: "text", text: content.text });
+          if (structuredData === void 0) {
+            try {
+              structuredData = JSON.parse(content.text);
+            } catch {
+            }
+          }
+        } else if (content.type === "refusal") {
+          textContent.push({ type: "text", text: content.refusal });
+          hadRefusal = true;
+        }
+      }
+    } else if (item.type === "function_call") {
+      const functionCall = item;
+      let args = {};
+      try {
+        args = JSON.parse(functionCall.arguments);
+      } catch {
+      }
+      toolCalls.push({
+        toolCallId: functionCall.call_id,
+        toolName: functionCall.name,
+        arguments: args
+      });
+      functionCallItems.push({
+        id: functionCall.id,
+        call_id: functionCall.call_id,
+        name: functionCall.name,
+        arguments: functionCall.arguments
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: data.id,
+      metadata: {
+        xai: {
+          model: data.model,
+          status: data.status,
+          // Store response_id for multi-turn tool calling
+          response_id: data.id,
+          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0,
+          citations: data.citations,
+          inline_citations: data.inline_citations
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.input_tokens,
+    outputTokens: data.usage.output_tokens,
+    totalTokens: data.usage.total_tokens
+  };
+  let stopReason = "end_turn";
+  if (data.status === "completed") {
+    stopReason = toolCalls.length > 0 ? "tool_use" : "end_turn";
+  } else if (data.status === "incomplete") {
+    stopReason = data.incomplete_details?.reason === "max_output_tokens" ? "max_tokens" : "end_turn";
+  } else if (data.status === "failed") {
+    stopReason = "error";
+  }
+  if (hadRefusal && stopReason !== "error") {
+    stopReason = "content_filter";
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+function createStreamState2() {
+  return {
+    id: "",
+    model: "",
+    textByIndex: /* @__PURE__ */ new Map(),
+    toolCalls: /* @__PURE__ */ new Map(),
+    status: "in_progress",
+    inputTokens: 0,
+    outputTokens: 0,
+    hadRefusal: false
+  };
+}
+function transformStreamEvent2(event, state) {
+  const events = [];
+  switch (event.type) {
+    case "response.created":
+      state.id = event.response.id;
+      state.model = event.response.model;
+      events.push({ type: "message_start", index: 0, delta: {} });
+      break;
+    case "response.in_progress":
+      state.status = "in_progress";
+      break;
+    case "response.completed":
+      state.status = "completed";
+      if (event.response.usage) {
+        state.inputTokens = event.response.usage.input_tokens;
+        state.outputTokens = event.response.usage.output_tokens;
+      }
+      events.push({ type: "message_stop", index: 0, delta: {} });
+      break;
+    case "response.failed":
+      state.status = "failed";
+      events.push({ type: "message_stop", index: 0, delta: {} });
+      break;
+    case "response.output_item.added":
+      if (event.item.type === "function_call") {
+        const functionCall = event.item;
+        const existing = state.toolCalls.get(event.output_index) ?? {
+          arguments: ""
+        };
+        existing.itemId = functionCall.id;
+        existing.callId = functionCall.call_id;
+        existing.name = functionCall.name;
+        if (functionCall.arguments) {
+          existing.arguments = functionCall.arguments;
+        }
+        state.toolCalls.set(event.output_index, existing);
+      }
+      events.push({
+        type: "content_block_start",
+        index: event.output_index,
+        delta: {}
+      });
+      break;
+    case "response.output_item.done":
+      if (event.item.type === "function_call") {
+        const functionCall = event.item;
+        const existing = state.toolCalls.get(event.output_index) ?? {
+          arguments: ""
+        };
+        existing.itemId = functionCall.id;
+        existing.callId = functionCall.call_id;
+        existing.name = functionCall.name;
+        if (functionCall.arguments) {
+          existing.arguments = functionCall.arguments;
+        }
+        state.toolCalls.set(event.output_index, existing);
+      }
+      events.push({
+        type: "content_block_stop",
+        index: event.output_index,
+        delta: {}
+      });
+      break;
+    case "response.output_text.delta":
+      const currentText = state.textByIndex.get(event.output_index) ?? "";
+      state.textByIndex.set(event.output_index, currentText + event.delta);
+      events.push({
+        type: "text_delta",
+        index: event.output_index,
+        delta: { text: event.delta }
+      });
+      break;
+    case "response.output_text.done":
+      state.textByIndex.set(event.output_index, event.text);
+      break;
+    case "response.refusal.delta": {
+      state.hadRefusal = true;
+      const currentRefusal = state.textByIndex.get(event.output_index) ?? "";
+      state.textByIndex.set(event.output_index, currentRefusal + event.delta);
+      events.push({
+        type: "text_delta",
+        index: event.output_index,
+        delta: { text: event.delta }
+      });
+      break;
+    }
+    case "response.refusal.done":
+      state.hadRefusal = true;
+      state.textByIndex.set(event.output_index, event.refusal);
+      break;
+    case "response.function_call_arguments.delta": {
+      let toolCall = state.toolCalls.get(event.output_index);
+      if (!toolCall) {
+        toolCall = { arguments: "" };
+        state.toolCalls.set(event.output_index, toolCall);
+      }
+      if (event.item_id && !toolCall.itemId) {
+        toolCall.itemId = event.item_id;
+      }
+      if (event.call_id && !toolCall.callId) {
+        toolCall.callId = event.call_id;
+      }
+      toolCall.arguments += event.delta;
+      events.push({
+        type: "tool_call_delta",
+        index: event.output_index,
+        delta: {
+          toolCallId: toolCall.callId ?? toolCall.itemId ?? "",
+          toolName: toolCall.name,
+          argumentsJson: event.delta
+        }
+      });
+      break;
+    }
+    case "response.function_call_arguments.done": {
+      let toolCall = state.toolCalls.get(event.output_index);
+      if (!toolCall) {
+        toolCall = { arguments: "" };
+        state.toolCalls.set(event.output_index, toolCall);
+      }
+      if (event.item_id) {
+        toolCall.itemId = event.item_id;
+      }
+      if (event.call_id) {
+        toolCall.callId = event.call_id;
+      }
+      toolCall.name = event.name;
+      toolCall.arguments = event.arguments;
+      break;
+    }
+    case "error":
+      break;
+    default:
+      break;
+  }
+  return events;
+}
+function buildResponseFromState2(state) {
+  const textContent = [];
+  let structuredData;
+  for (const [, text] of state.textByIndex) {
+    if (text) {
+      textContent.push({ type: "text", text });
+      if (structuredData === void 0) {
+        try {
+          structuredData = JSON.parse(text);
+        } catch {
+        }
+      }
+    }
+  }
+  const toolCalls = [];
+  const functionCallItems = [];
+  for (const [, toolCall] of state.toolCalls) {
+    let args = {};
+    if (toolCall.arguments) {
+      try {
+        args = JSON.parse(toolCall.arguments);
+      } catch {
+      }
+    }
+    const itemId = toolCall.itemId ?? "";
+    const callId = toolCall.callId ?? toolCall.itemId ?? "";
+    const name = toolCall.name ?? "";
+    toolCalls.push({
+      toolCallId: callId,
+      toolName: name,
+      arguments: args
+    });
+    if (itemId && callId && name) {
+      functionCallItems.push({
+        id: itemId,
+        call_id: callId,
+        name,
+        arguments: toolCall.arguments
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: state.id,
+      metadata: {
+        xai: {
+          model: state.model,
+          status: state.status,
+          // Store response_id for multi-turn tool calling
+          response_id: state.id,
+          functionCallItems: functionCallItems.length > 0 ? functionCallItems : void 0
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens
+  };
+  let stopReason = "end_turn";
+  if (state.status === "completed") {
+    stopReason = toolCalls.length > 0 ? "tool_use" : "end_turn";
+  } else if (state.status === "failed") {
+    stopReason = "error";
+  }
+  if (state.hadRefusal && stopReason !== "error") {
+    stopReason = "content_filter";
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+
+// src/providers/xai/llm.responses.ts
+var XAI_RESPONSES_API_URL = "https://api.x.ai/v1/responses";
+var XAI_RESPONSES_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  videoInput: false,
+  audioInput: false
+};
+function createResponsesLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider() or have _setProvider called.",
+          "INVALID_REQUEST",
+          "xai",
+          "llm"
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: XAI_RESPONSES_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const apiKey = await resolveApiKey(
+            request.config,
+            "XAI_API_KEY",
+            "xai",
+            "llm"
+          );
+          const baseUrl = request.config.baseUrl ?? XAI_RESPONSES_API_URL;
+          const body = transformRequest2(request, modelId);
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`
+              },
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "xai",
+            "llm"
+          );
+          const data = await response.json();
+          if (data.status === "failed" && data.error) {
+            throw new UPPError(
+              data.error.message,
+              "PROVIDER_ERROR",
+              "xai",
+              "llm"
+            );
+          }
+          return transformResponse2(data);
+        },
+        stream(request) {
+          const state = createStreamState2();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const apiKey = await resolveApiKey(
+                request.config,
+                "XAI_API_KEY",
+                "xai",
+                "llm"
+              );
+              const baseUrl = request.config.baseUrl ?? XAI_RESPONSES_API_URL;
+              const body = transformRequest2(request, modelId);
+              body.stream = true;
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`
+                  },
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "xai",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "xai", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  "PROVIDER_ERROR",
+                  "xai",
+                  "llm"
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (data === "[DONE]") {
+                  continue;
+                }
+                if (typeof data === "object" && data !== null) {
+                  const event = data;
+                  if (event.type === "error") {
+                    const errorEvent = event;
+                    const error = new UPPError(
+                      errorEvent.error.message,
+                      "PROVIDER_ERROR",
+                      "xai",
+                      "llm"
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvents = transformStreamEvent2(event, state);
+                  for (const uppEvent of uppEvents) {
+                    yield uppEvent;
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState2(state));
+            } catch (error) {
+              responseReject(error);
+              throw error;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/xai/transform.messages.ts
+function transformRequest3(request, modelId) {
+  const params = request.params ?? {};
+  const xaiRequest = {
+    model: modelId,
+    messages: request.messages.map(transformMessage3)
+  };
+  if (params.max_tokens !== void 0) {
+    xaiRequest.max_tokens = params.max_tokens;
+  }
+  if (request.system) {
+    xaiRequest.system = request.system;
+  }
+  if (params.temperature !== void 0) {
+    xaiRequest.temperature = params.temperature;
+  }
+  if (params.top_p !== void 0) {
+    xaiRequest.top_p = params.top_p;
+  }
+  if (params.top_k !== void 0) {
+    xaiRequest.top_k = params.top_k;
+  }
+  if (params.stop_sequences) {
+    xaiRequest.stop_sequences = params.stop_sequences;
+  }
+  if (params.messages_metadata) {
+    xaiRequest.metadata = params.messages_metadata;
+  }
+  if (params.thinking) {
+    xaiRequest.thinking = params.thinking;
+  }
+  if (request.tools && request.tools.length > 0) {
+    xaiRequest.tools = request.tools.map(transformTool3);
+    xaiRequest.tool_choice = { type: "auto" };
+  }
+  if (request.structure) {
+    const structuredTool = {
+      name: "json_response",
+      description: "Return the response in the specified JSON format. You MUST use this tool to provide your response.",
+      input_schema: {
+        type: "object",
+        properties: request.structure.properties,
+        required: request.structure.required
+      }
+    };
+    xaiRequest.tools = [...xaiRequest.tools ?? [], structuredTool];
+    xaiRequest.tool_choice = { type: "tool", name: "json_response" };
+  }
+  return xaiRequest;
+}
+function filterValidContent3(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformMessage3(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent3(message.content);
+    return {
+      role: "user",
+      content: validContent.map(transformContentBlock2)
+    };
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent3(message.content);
+    const content = validContent.map(transformContentBlock2);
+    if (message.toolCalls) {
+      for (const call of message.toolCalls) {
+        content.push({
+          type: "tool_use",
+          id: call.toolCallId,
+          name: call.toolName,
+          input: call.arguments
+        });
+      }
+    }
+    if (content.length === 0) {
+      content.push({ type: "text", text: "" });
+    }
+    return {
+      role: "assistant",
+      content
+    };
+  }
+  if (isToolResultMessage(message)) {
+    return {
+      role: "user",
+      content: message.results.map((result) => ({
+        type: "tool_result",
+        tool_use_id: result.toolCallId,
+        content: typeof result.result === "string" ? result.result : JSON.stringify(result.result),
+        is_error: result.isError
+      }))
+    };
+  }
+  throw new Error(`Unknown message type: ${message.type}`);
+}
+function transformContentBlock2(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "image": {
+      const imageBlock = block;
+      if (imageBlock.source.type === "base64") {
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: imageBlock.mimeType,
+            data: imageBlock.source.data
+          }
+        };
+      }
+      if (imageBlock.source.type === "url") {
+        return {
+          type: "image",
+          source: {
+            type: "url",
+            url: imageBlock.source.url
+          }
+        };
+      }
+      if (imageBlock.source.type === "bytes") {
+        const base64 = btoa(
+          Array.from(imageBlock.source.data).map((b) => String.fromCharCode(b)).join("")
+        );
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: imageBlock.mimeType,
+            data: base64
+          }
+        };
+      }
+      throw new Error(`Unknown image source type`);
+    }
+    default:
+      throw new Error(`Unsupported content type: ${block.type}`);
+  }
+}
+function transformTool3(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: {
+      type: "object",
+      properties: tool.parameters.properties,
+      required: tool.parameters.required
+    }
+  };
+}
+function transformResponse3(data) {
+  const textContent = [];
+  const toolCalls = [];
+  let structuredData;
+  for (const block of data.content) {
+    if (block.type === "text") {
+      textContent.push({ type: "text", text: block.text });
+    } else if (block.type === "tool_use") {
+      if (block.name === "json_response") {
+        structuredData = block.input;
+      }
+      toolCalls.push({
+        toolCallId: block.id,
+        toolName: block.name,
+        arguments: block.input
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: data.id,
+      metadata: {
+        xai: {
+          stop_reason: data.stop_reason,
+          stop_sequence: data.stop_sequence,
+          model: data.model
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.input_tokens,
+    outputTokens: data.usage.output_tokens,
+    totalTokens: data.usage.input_tokens + data.usage.output_tokens
+  };
+  return {
+    message,
+    usage,
+    stopReason: data.stop_reason ?? "end_turn",
+    data: structuredData
+  };
+}
+function createStreamState3() {
+  return {
+    messageId: "",
+    model: "",
+    content: [],
+    stopReason: null,
+    inputTokens: 0,
+    outputTokens: 0,
+    currentIndex: 0
+  };
+}
+function transformStreamEvent3(event, state) {
+  switch (event.type) {
+    case "message_start":
+      state.messageId = event.message.id;
+      state.model = event.message.model;
+      state.inputTokens = event.message.usage.input_tokens;
+      return { type: "message_start", index: 0, delta: {} };
+    case "content_block_start":
+      state.currentIndex = event.index;
+      if (event.content_block.type === "text") {
+        state.content[event.index] = { type: "text", text: "" };
+      } else if (event.content_block.type === "tool_use") {
+        state.content[event.index] = {
+          type: "tool_use",
+          id: event.content_block.id,
+          name: event.content_block.name,
+          input: ""
+        };
+      }
+      return { type: "content_block_start", index: event.index, delta: {} };
+    case "content_block_delta": {
+      const delta = event.delta;
+      const index = event.index ?? state.currentIndex;
+      if (delta.type === "text_delta") {
+        if (!state.content[index]) {
+          state.content[index] = { type: "text", text: "" };
+        }
+        state.content[index].text = (state.content[index].text ?? "") + delta.text;
+        return {
+          type: "text_delta",
+          index,
+          delta: { text: delta.text }
+        };
+      }
+      if (delta.type === "input_json_delta") {
+        if (!state.content[index]) {
+          state.content[index] = { type: "tool_use", id: "", name: "", input: "" };
+        }
+        state.content[index].input = (state.content[index].input ?? "") + delta.partial_json;
+        return {
+          type: "tool_call_delta",
+          index,
+          delta: {
+            argumentsJson: delta.partial_json,
+            toolCallId: state.content[index]?.id,
+            toolName: state.content[index]?.name
+          }
+        };
+      }
+      if (delta.type === "thinking_delta") {
+        return {
+          type: "reasoning_delta",
+          index,
+          delta: { text: delta.thinking }
+        };
+      }
+      return null;
+    }
+    case "content_block_stop":
+      return { type: "content_block_stop", index: event.index ?? state.currentIndex, delta: {} };
+    case "message_delta":
+      state.stopReason = event.delta.stop_reason;
+      state.outputTokens = event.usage.output_tokens;
+      return null;
+    case "message_stop":
+      return { type: "message_stop", index: 0, delta: {} };
+    case "ping":
+    case "error":
+      return null;
+    default:
+      return null;
+  }
+}
+function buildResponseFromState3(state) {
+  const textContent = [];
+  const toolCalls = [];
+  let structuredData;
+  for (const block of state.content) {
+    if (block.type === "text" && block.text) {
+      textContent.push({ type: "text", text: block.text });
+    } else if (block.type === "tool_use" && block.id && block.name) {
+      let args = {};
+      if (block.input) {
+        try {
+          args = JSON.parse(block.input);
+        } catch {
+        }
+      }
+      if (block.name === "json_response") {
+        structuredData = args;
+      }
+      toolCalls.push({
+        toolCallId: block.id,
+        toolName: block.name,
+        arguments: args
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: state.messageId,
+      metadata: {
+        xai: {
+          stop_reason: state.stopReason,
+          model: state.model
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens
+  };
+  return {
+    message,
+    usage,
+    stopReason: state.stopReason ?? "end_turn",
+    data: structuredData
+  };
+}
+
+// src/providers/xai/llm.messages.ts
+var XAI_MESSAGES_API_URL = "https://api.x.ai/v1/messages";
+var XAI_MESSAGES_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  videoInput: false,
+  audioInput: false
+};
+function createMessagesLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider() or have _setProvider called.",
+          "INVALID_REQUEST",
+          "xai",
+          "llm"
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: XAI_MESSAGES_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const apiKey = await resolveApiKey(
+            request.config,
+            "XAI_API_KEY",
+            "xai",
+            "llm"
+          );
+          const baseUrl = request.config.baseUrl ?? XAI_MESSAGES_API_URL;
+          const body = transformRequest3(request, modelId);
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01"
+              },
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "xai",
+            "llm"
+          );
+          const data = await response.json();
+          return transformResponse3(data);
+        },
+        stream(request) {
+          const state = createStreamState3();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const apiKey = await resolveApiKey(
+                request.config,
+                "XAI_API_KEY",
+                "xai",
+                "llm"
+              );
+              const baseUrl = request.config.baseUrl ?? XAI_MESSAGES_API_URL;
+              const body = transformRequest3(request, modelId);
+              body.stream = true;
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "anthropic-version": "2023-06-01"
+                  },
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "xai",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "xai", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  "PROVIDER_ERROR",
+                  "xai",
+                  "llm"
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (typeof data === "object" && data !== null && "type" in data) {
+                  const event = data;
+                  if (event.type === "error") {
+                    const error = new UPPError(
+                      event.error.message,
+                      "PROVIDER_ERROR",
+                      "xai",
+                      "llm"
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvent = transformStreamEvent3(event, state);
+                  if (uppEvent) {
+                    yield uppEvent;
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState3(state));
+            } catch (error) {
+              responseReject(error);
+              throw error;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/xai/index.ts
+function createXAIProvider() {
+  let currentApiMode = "completions";
+  const completionsHandler = createCompletionsLLMHandler();
+  const responsesHandler = createResponsesLLMHandler();
+  const messagesHandler = createMessagesLLMHandler();
+  const fn = function(modelId, options) {
+    const apiMode = options?.api ?? "completions";
+    currentApiMode = apiMode;
+    return { modelId, provider };
+  };
+  const modalities = {
+    get llm() {
+      switch (currentApiMode) {
+        case "responses":
+          return responsesHandler;
+        case "messages":
+          return messagesHandler;
+        case "completions":
+        default:
+          return completionsHandler;
+      }
+    }
+  };
+  Object.defineProperties(fn, {
+    name: {
+      value: "xai",
+      writable: false,
+      configurable: true
+    },
+    version: {
+      value: "1.0.0",
+      writable: false,
+      configurable: true
+    },
+    modalities: {
+      value: modalities,
+      writable: false,
+      configurable: true
+    }
+  });
+  const provider = fn;
+  completionsHandler._setProvider?.(provider);
+  responsesHandler._setProvider?.(provider);
+  messagesHandler._setProvider?.(provider);
+  return provider;
+}
+var xai = createXAIProvider();
+export {
+  xai
+};
+//# sourceMappingURL=index.js.map