@yourgpt/llm-sdk 0.1.0 → 1.0.0

package/dist/providers/xai/index.js

@@ -0,0 +1,671 @@
+'use strict';
+
+var core = require('@yourgpt/copilot-sdk/core');
+
+// src/providers/xai/provider.ts
+var XAI_MODELS = {
+  // Grok 4.1 Fast (Latest - December 2025)
+  "grok-4-1-fast-reasoning": { vision: false, tools: true, maxTokens: 2e6 },
+  "grok-4-1-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6
+  },
+  // Grok 4 Fast (September 2025)
+  "grok-4-fast-reasoning": { vision: false, tools: true, maxTokens: 2e6 },
+  "grok-4-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6
+  },
+  // Grok 4 (July 2025)
+  "grok-4": { vision: true, tools: true, maxTokens: 256e3 },
+  "grok-4-0709": { vision: true, tools: true, maxTokens: 256e3 },
+  // Grok 3 (February 2025) - Stable
+  "grok-3-beta": { vision: true, tools: true, maxTokens: 131072 },
+  "grok-3-fast-beta": { vision: false, tools: true, maxTokens: 131072 },
+  "grok-3-mini-beta": { vision: false, tools: true, maxTokens: 32768 },
+  "grok-3-mini-fast-beta": { vision: false, tools: true, maxTokens: 32768 },
+  // Grok Code Fast (August 2025)
+  "grok-code-fast-1": { vision: false, tools: true, maxTokens: 256e3 },
+  // Grok 2 (Legacy)
+  "grok-2": { vision: true, tools: true, maxTokens: 131072 },
+  "grok-2-latest": { vision: true, tools: true, maxTokens: 131072 },
+  "grok-2-mini": { vision: false, tools: true, maxTokens: 131072 }
+};
+function xai(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.XAI_API_KEY;
+  const baseURL = options.baseURL ?? "https://api.x.ai/v1";
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { default: OpenAI } = await import('openai');
+      client = new OpenAI({
+        apiKey,
+        baseURL
+      });
+    }
+    return client;
+  }
+  const modelConfig = XAI_MODELS[modelId] ?? XAI_MODELS["grok-3-fast-beta"];
+  return {
+    provider: "xai",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      // xAI doesn't support JSON mode yet
+      supportsThinking: false,
+      supportsPDF: false,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      const client2 = await getClient();
+      const messages = formatMessagesForXAI(params.messages);
+      const response = await client2.chat.completions.create({
+        model: modelId,
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.maxTokens
+      });
+      const choice = response.choices[0];
+      const message = choice.message;
+      const toolCalls = (message.tool_calls ?? []).map(
+        (tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          args: JSON.parse(tc.function.arguments || "{}")
+        })
+      );
+      return {
+        text: message.content ?? "",
+        toolCalls,
+        finishReason: mapFinishReason(choice.finish_reason),
+        usage: {
+          promptTokens: response.usage?.prompt_tokens ?? 0,
+          completionTokens: response.usage?.completion_tokens ?? 0,
+          totalTokens: response.usage?.total_tokens ?? 0
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      const client2 = await getClient();
+      const messages = formatMessagesForXAI(params.messages);
+      const stream = await client2.chat.completions.create({
+        model: modelId,
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      let totalPromptTokens = 0;
+      let totalCompletionTokens = 0;
+      for await (const chunk of stream) {
+        if (params.signal?.aborted) {
+          yield { type: "error", error: new Error("Aborted") };
+          return;
+        }
+        const choice = chunk.choices[0];
+        const delta = choice?.delta;
+        if (delta?.content) {
+          yield { type: "text-delta", text: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (tc.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "tool-call",
+                  toolCall: {
+                    id: currentToolCall.id,
+                    name: currentToolCall.name,
+                    args: JSON.parse(currentToolCall.arguments || "{}")
+                  }
+                };
+              }
+              currentToolCall = {
+                id: tc.id,
+                name: tc.function?.name ?? "",
+                arguments: tc.function?.arguments ?? ""
+              };
+            } else if (currentToolCall && tc.function?.arguments) {
+              currentToolCall.arguments += tc.function.arguments;
+            }
+          }
+        }
+        if (choice?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "tool-call",
+              toolCall: {
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                args: JSON.parse(currentToolCall.arguments || "{}")
+              }
+            };
+            currentToolCall = null;
+          }
+          if (chunk.usage) {
+            totalPromptTokens = chunk.usage.prompt_tokens;
+            totalCompletionTokens = chunk.usage.completion_tokens;
+          }
+          yield {
+            type: "finish",
+            finishReason: mapFinishReason(choice.finish_reason),
+            usage: {
+              promptTokens: totalPromptTokens,
+              completionTokens: totalCompletionTokens,
+              totalTokens: totalPromptTokens + totalCompletionTokens
+            }
+          };
+        }
+      }
+    }
+  };
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "unknown";
+  }
+}
+function formatMessagesForXAI(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "system":
+        return { role: "system", content: msg.content };
+      case "user":
+        if (typeof msg.content === "string") {
+          return { role: "user", content: msg.content };
+        }
+        return {
+          role: "user",
+          content: msg.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            if (part.type === "image") {
+              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+              return { type: "image_url", image_url: { url, detail: "auto" } };
+            }
+            return { type: "text", text: "" };
+          })
+        };
+      case "assistant":
+        const assistantMsg = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }));
+        }
+        return assistantMsg;
+      case "tool":
+        return {
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: msg.content
+        };
+      default:
+        return msg;
+    }
+  });
+}
+
+// src/adapters/base.ts
+function parameterToJsonSchema(param) {
+  const schema = {
+    type: param.type
+  };
+  if (param.description) {
+    schema.description = param.description;
+  }
+  if (param.enum) {
+    schema.enum = param.enum;
+  }
+  if (param.type === "array" && param.items) {
+    schema.items = parameterToJsonSchema(
+      param.items
+    );
+  }
+  if (param.type === "object" && param.properties) {
+    schema.properties = Object.fromEntries(
+      Object.entries(param.properties).map(([key, prop]) => [
+        key,
+        parameterToJsonSchema(
+          prop
+        )
+      ])
+    );
+  }
+  return schema;
+}
+function formatTools(actions) {
+  return actions.map((action) => ({
+    type: "function",
+    function: {
+      name: action.name,
+      description: action.description,
+      parameters: {
+        type: "object",
+        properties: action.parameters ? Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            parameterToJsonSchema(param)
+          ])
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
+      }
+    }
+  }));
+}
+function hasImageAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some((a) => a.type === "image") ?? false;
+}
+function attachmentToOpenAIImage(attachment) {
+  if (attachment.type !== "image") return null;
+  let imageUrl;
+  if (attachment.url) {
+    imageUrl = attachment.url;
+  } else if (attachment.data) {
+    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+  } else {
+    return null;
+  }
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageUrl,
+      detail: "auto"
+    }
+  };
+}
+function messageToOpenAIContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasImageAttachments(message)) {
+    return content;
+  }
+  const blocks = [];
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToOpenAIImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+      }
+    }
+  }
+  return blocks;
+}
+function formatMessagesForOpenAI(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      formatted.push({ role: "system", content: msg.content ?? "" });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToOpenAIContent(msg)
+      });
+    } else if (msg.role === "assistant") {
+      const assistantMsg = {
+        role: "assistant",
+        content: msg.content
+      };
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        assistantMsg.tool_calls = msg.tool_calls;
+      }
+      formatted.push(assistantMsg);
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      formatted.push({
+        role: "tool",
+        content: msg.content ?? "",
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  return formatted;
+}
+
+// src/adapters/xai.ts
+var XAI_BASE_URL = "https://api.x.ai/v1";
+var XAIAdapter = class {
+  constructor(config) {
+    this.provider = "xai";
+    this.config = config;
+    this.model = config.model || "grok-2";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: OpenAI } = await import('openai');
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl || XAI_BASE_URL
+      });
+    }
+    return this.client;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      const processedMessages = request.rawMessages.map((msg) => {
+        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
+        if (hasAttachments) {
+          const content = [];
+          if (msg.content) {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              let imageUrl = attachment.data;
+              if (!imageUrl.startsWith("data:")) {
+                imageUrl = `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              }
+              content.push({
+                type: "image_url",
+                image_url: { url: imageUrl, detail: "auto" }
+              });
+            }
+          }
+          return { ...msg, content, attachments: void 0 };
+        }
+        return msg;
+      });
+      if (request.systemPrompt) {
+        const hasSystem = processedMessages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...processedMessages
+          ];
+        } else {
+          messages = processedMessages;
+        }
+      } else {
+        messages = processedMessages;
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const stream = await client.chat.completions.create({
+        model: request.config?.model || this.model,
+        messages,
+        tools,
+        temperature: request.config?.temperature ?? this.config.temperature,
+        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      for await (const chunk of stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          yield { type: "message:delta", content: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const toolCall of delta.tool_calls) {
+            if (toolCall.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "action:args",
+                  id: currentToolCall.id,
+                  args: currentToolCall.arguments
+                };
+              }
+              currentToolCall = {
+                id: toolCall.id,
+                name: toolCall.function?.name || "",
+                arguments: toolCall.function?.arguments || ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolCall.id,
+                name: currentToolCall.name
+              };
+            } else if (currentToolCall && toolCall.function?.arguments) {
+              currentToolCall.arguments += toolCall.function.arguments;
+            }
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: currentToolCall.arguments
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "XAI_ERROR"
+      };
+    }
+  }
+  /**
+   * Non-streaming completion (optional, for debugging)
+   */
+  async complete(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      messages = request.rawMessages;
+      if (request.systemPrompt) {
+        const hasSystem = messages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...messages
+          ];
+        }
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const response = await client.chat.completions.create({
+      model: request.config?.model || this.model,
+      messages,
+      tools,
+      temperature: request.config?.temperature ?? this.config.temperature,
+      max_tokens: request.config?.maxTokens ?? this.config.maxTokens
+    });
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const toolCalls = (message?.tool_calls || []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      args: JSON.parse(tc.function.arguments || "{}")
+    }));
+    return {
+      content: message?.content || "",
+      toolCalls,
+      rawResponse: response
+    };
+  }
+};
+function createXAIAdapter(config) {
+  return new XAIAdapter(config);
+}
+
+// src/providers/xai/index.ts
+var XAI_MODELS2 = {
+  // Grok 4.1 Fast (Latest - December 2025)
+  "grok-4-1-fast-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  "grok-4-1-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  // Grok 4 Fast (September 2025)
+  "grok-4-fast-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  "grok-4-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  // Grok 4 (July 2025)
+  "grok-4": {
+    vision: true,
+    tools: true,
+    maxTokens: 256e3,
+    outputTokens: 16384
+  },
+  "grok-4-0709": {
+    vision: true,
+    tools: true,
+    maxTokens: 256e3,
+    outputTokens: 16384
+  },
+  // Grok 3 (February 2025) - Stable
+  "grok-3-beta": {
+    vision: true,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 8192
+  },
+  "grok-3-fast-beta": {
+    vision: false,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 8192
+  },
+  "grok-3-mini-beta": {
+    vision: false,
+    tools: true,
+    maxTokens: 32768,
+    outputTokens: 8192
+  },
+  "grok-3-mini-fast-beta": {
+    vision: false,
+    tools: true,
+    maxTokens: 32768,
+    outputTokens: 8192
+  },
+  // Grok Code Fast (August 2025)
+  "grok-code-fast-1": {
+    vision: false,
+    tools: true,
+    maxTokens: 256e3,
+    outputTokens: 16384
+  },
+  // Grok 2 (Legacy - for backward compatibility)
+  "grok-2": {
+    vision: true,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-2-latest": {
+    vision: true,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-2-mini": {
+    vision: false,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  }
+};
+function createXAI(config = {}) {
+  const apiKey = config.apiKey ?? process.env.XAI_API_KEY ?? "";
+  return {
+    name: "xai",
+    supportedModels: Object.keys(XAI_MODELS2),
+    languageModel(modelId) {
+      return createXAIAdapter({
+        apiKey,
+        model: modelId,
+        baseUrl: config.baseUrl
+      });
+    },
+    getCapabilities(modelId) {
+      const model = XAI_MODELS2[modelId] ?? XAI_MODELS2["grok-3-fast-beta"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        supportsStreaming: true,
+        supportsPDF: false,
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
+        supportsJsonMode: false,
+        // xAI doesn't support JSON mode yet
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+var createXAIProvider = createXAI;
+
+exports.createXAI = createXAI;
+exports.createXAIModel = xai;
+exports.createXAIProvider = createXAIProvider;
+exports.xai = xai;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map