@yourgpt/llm-sdk 1.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 YourGPT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,7 +5,13 @@ Multi-provider LLM SDK with streaming. One API, any provider.
 ## Installation
 
 ```bash
-npm install @yourgpt/llm-sdk
+npm install @yourgpt/llm-sdk openai
+```
+
+For Anthropic, install `@anthropic-ai/sdk` instead:
+
+```bash
+npm install @yourgpt/llm-sdk @anthropic-ai/sdk
 ```
 
 ## Quick Start
@@ -18,7 +24,7 @@ export async function POST(req: Request) {
   const { messages } = await req.json();
 
   const result = await streamText({
-    model: openai("gpt-5"),
+    model: openai("gpt-4o"),
     system: "You are a helpful assistant.",
     messages,
   });
@@ -36,16 +42,16 @@ import { google } from "@yourgpt/llm-sdk/google";
 import { xai } from "@yourgpt/llm-sdk/xai";
 
 // OpenAI
-await streamText({ model: openai("gpt-5"), messages });
+await streamText({ model: openai("gpt-4o"), messages });
 
 // Anthropic
 await streamText({ model: anthropic("claude-sonnet-4-20250514"), messages });
 
-// Google
+// Google Gemini (uses OpenAI-compatible API)
 await streamText({ model: google("gemini-2.0-flash"), messages });
 
-// xAI
-await streamText({ model: xai("grok-3"), messages });
+// xAI Grok (uses OpenAI-compatible API)
+await streamText({ model: xai("grok-3-fast-beta"), messages });
 ```
 
 ## Server-Side Tools
@@ -56,7 +62,7 @@ import { openai } from "@yourgpt/llm-sdk/openai";
 import { z } from "zod";
 
 const result = await streamText({
-  model: openai("gpt-5"),
+  model: openai("gpt-4o"),
   messages,
   tools: {
     getWeather: tool({
@@ -77,14 +83,16 @@ return result.toDataStreamResponse();
 
 ## Supported Providers
 
-| Provider      | Import                       |
-| ------------- | ---------------------------- |
-| OpenAI        | `@yourgpt/llm-sdk/openai`    |
-| Anthropic     | `@yourgpt/llm-sdk/anthropic` |
-| Google Gemini | `@yourgpt/llm-sdk/google`    |
-| xAI (Grok)    | `@yourgpt/llm-sdk/xai`       |
-| Ollama        | `@yourgpt/llm-sdk/ollama`    |
-| Azure OpenAI  | `@yourgpt/llm-sdk/azure`     |
+| Provider      | Import                       | SDK Required        |
+| ------------- | ---------------------------- | ------------------- |
+| OpenAI        | `@yourgpt/llm-sdk/openai`    | `openai`            |
+| Anthropic     | `@yourgpt/llm-sdk/anthropic` | `@anthropic-ai/sdk` |
+| Google Gemini | `@yourgpt/llm-sdk/google`    | `openai`            |
+| xAI (Grok)    | `@yourgpt/llm-sdk/xai`       | `openai`            |
+| Ollama        | `@yourgpt/llm-sdk/ollama`    | `openai`            |
+| Azure OpenAI  | `@yourgpt/llm-sdk/azure`     | `openai`            |
+
+> **Note:** OpenAI, Google, xAI, Ollama, and Azure all use the `openai` SDK because they have OpenAI-compatible APIs. Only Anthropic requires its native SDK for full feature support.
 
 ## Documentation
 

package/dist/index.js

@@ -1393,6 +1393,21 @@ function formatMessagesForXAI(messages) {
 
 // src/providers/google/provider.ts
 var GOOGLE_MODELS = {
+  // Gemini 2.5 (Experimental)
+  "gemini-2.5-pro-preview-05-06": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-2.5-flash-preview-05-20": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
   // Gemini 2.0
   "gemini-2.0-flash": {
     vision: true,
@@ -1408,6 +1423,13 @@ var GOOGLE_MODELS = {
     video: true,
     maxTokens: 1048576
   },
+  "gemini-2.0-flash-lite": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    maxTokens: 1048576
+  },
   "gemini-2.0-flash-thinking-exp": {
     vision: true,
     tools: false,
@@ -1454,11 +1476,15 @@ var GOOGLE_MODELS = {
 };
 function google(modelId, options = {}) {
   const apiKey = options.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+  const baseURL = options.baseURL ?? "https://generativelanguage.googleapis.com/v1beta/openai/";
   let client = null;
   async function getClient() {
     if (!client) {
-      const { GoogleGenerativeAI } = await import('@google/generative-ai');
-      client = new GoogleGenerativeAI(apiKey);
+      const { default: OpenAI } = await import('openai');
+      client = new OpenAI({
+        apiKey,
+        baseURL
+      });
     }
     return client;
   }
@@ -1478,219 +1504,176 @@ function google(modelId, options = {}) {
     },
     async doGenerate(params) {
       const client2 = await getClient();
-      const model = client2.getGenerativeModel({
+      const messages = formatMessagesForGoogle(params.messages);
+      const response = await client2.chat.completions.create({
         model: modelId,
-        safetySettings: options.safetySettings
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.maxTokens
       });
-      const { systemInstruction, contents } = formatMessagesForGemini(
-        params.messages
+      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 || "{}")
+        })
       );
-      const chat = model.startChat({
-        history: contents.slice(0, -1),
-        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
-        tools: params.tools ? [{ functionDeclarations: formatToolsForGemini(params.tools) }] : void 0,
-        generationConfig: {
-          temperature: params.temperature,
-          maxOutputTokens: params.maxTokens
-        }
-      });
-      const lastMessage = contents[contents.length - 1];
-      const result = await chat.sendMessage(lastMessage.parts);
-      const response = result.response;
-      let text = "";
-      const toolCalls = [];
-      let toolCallIndex = 0;
-      const candidate = response.candidates?.[0];
-      if (candidate?.content?.parts) {
-        for (const part of candidate.content.parts) {
-          if ("text" in part && part.text) {
-            text += part.text;
-          }
-          if ("functionCall" in part && part.functionCall) {
-            toolCalls.push({
-              id: `call_${toolCallIndex++}`,
-              name: part.functionCall.name,
-              args: part.functionCall.args || {}
-            });
-          }
-        }
-      }
       return {
-        text,
+        text: message.content ?? "",
         toolCalls,
-        finishReason: mapFinishReason4(candidate?.finishReason),
+        finishReason: mapFinishReason4(choice.finish_reason),
         usage: {
-          promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
-          completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
-          totalTokens: response.usageMetadata?.totalTokenCount ?? 0
+          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 model = client2.getGenerativeModel({
+      const messages = formatMessagesForGoogle(params.messages);
+      const stream = await client2.chat.completions.create({
         model: modelId,
-        safetySettings: options.safetySettings
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.maxTokens,
+        stream: true
       });
-      const { systemInstruction, contents } = formatMessagesForGemini(
-        params.messages
-      );
-      const chat = model.startChat({
-        history: contents.slice(0, -1),
-        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
-        tools: params.tools ? [{ functionDeclarations: formatToolsForGemini(params.tools) }] : void 0,
-        generationConfig: {
-          temperature: params.temperature,
-          maxOutputTokens: params.maxTokens
+      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 lastMessage = contents[contents.length - 1];
-      const result = await chat.sendMessageStream(lastMessage.parts);
-      let toolCallIndex = 0;
-      let promptTokens = 0;
-      let completionTokens = 0;
-      try {
-        for await (const chunk of result.stream) {
-          if (params.signal?.aborted) {
-            yield { type: "error", error: new Error("Aborted") };
-            return;
-          }
-          const candidate = chunk.candidates?.[0];
-          if (!candidate?.content?.parts) continue;
-          for (const part of candidate.content.parts) {
-            if ("text" in part && part.text) {
-              yield { type: "text-delta", text: part.text };
-            }
-            if ("functionCall" in part && part.functionCall) {
-              yield {
-                type: "tool-call",
-                toolCall: {
-                  id: `call_${toolCallIndex++}`,
-                  name: part.functionCall.name,
-                  args: part.functionCall.args || {}
-                }
+        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 (chunk.usageMetadata) {
-            promptTokens = chunk.usageMetadata.promptTokenCount ?? 0;
-            completionTokens = chunk.usageMetadata.candidatesTokenCount ?? 0;
-          }
-          if (candidate.finishReason) {
+        }
+        if (choice?.finish_reason) {
+          if (currentToolCall) {
             yield {
-              type: "finish",
-              finishReason: mapFinishReason4(candidate.finishReason),
-              usage: {
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens
+              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: mapFinishReason4(choice.finish_reason),
+            usage: {
+              promptTokens: totalPromptTokens,
+              completionTokens: totalCompletionTokens,
+              totalTokens: totalPromptTokens + totalCompletionTokens
+            }
+          };
         }
-      } catch (error) {
-        yield {
-          type: "error",
-          error: error instanceof Error ? error : new Error(String(error))
-        };
       }
     }
   };
 }
 function mapFinishReason4(reason) {
   switch (reason) {
-    case "STOP":
+    case "stop":
       return "stop";
-    case "MAX_TOKENS":
+    case "length":
       return "length";
-    case "SAFETY":
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
       return "content-filter";
     default:
       return "unknown";
   }
 }
-function formatMessagesForGemini(messages) {
-  let systemInstruction = "";
-  const contents = [];
-  for (const msg of messages) {
-    if (msg.role === "system") {
-      systemInstruction += (systemInstruction ? "\n" : "") + msg.content;
-      continue;
-    }
-    const parts = [];
-    if (msg.role === "user") {
-      if (typeof msg.content === "string") {
-        parts.push({ text: msg.content });
-      } else {
-        for (const part of msg.content) {
-          if (part.type === "text") {
-            parts.push({ text: part.text });
-          } else if (part.type === "image") {
-            const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
-            const base64 = imageData.startsWith("data:") ? imageData.split(",")[1] : imageData;
-            parts.push({
-              inlineData: {
-                mimeType: part.mimeType ?? "image/png",
-                data: base64
-              }
-            });
-          }
+function formatMessagesForGoogle(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 };
         }
-      }
-      contents.push({ role: "user", parts });
-    } else if (msg.role === "assistant") {
-      if (msg.content) {
-        parts.push({ text: msg.content });
-      }
-      if (msg.toolCalls?.length) {
-        for (const tc of msg.toolCalls) {
-          parts.push({
-            functionCall: {
+        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,
-              args: tc.args
+              arguments: JSON.stringify(tc.args)
             }
-          });
+          }));
         }
-      }
-      if (parts.length > 0) {
-        contents.push({ role: "model", parts });
-      }
-    } else if (msg.role === "tool") {
-      contents.push({
-        role: "user",
-        parts: [
-          {
-            functionResponse: {
-              name: "tool",
-              // Gemini doesn't track by ID
-              response: JSON.parse(msg.content || "{}")
-            }
-          }
-        ]
-      });
-    }
-  }
-  if (contents.length === 0 || contents[0].role !== "user") {
-    contents.unshift({ role: "user", parts: [{ text: "" }] });
-  }
-  const merged = [];
-  for (const content of contents) {
-    const last = merged[merged.length - 1];
-    if (last && last.role === content.role) {
-      last.parts.push(...content.parts);
-    } else {
-      merged.push({ ...content, parts: [...content.parts] });
+        return assistantMsg;
+      case "tool":
+        return {
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: msg.content
+        };
+      default:
+        return msg;
     }
-  }
-  return { systemInstruction, contents: merged };
-}
-function formatToolsForGemini(tools) {
-  return tools.map((t) => ({
-    name: t.function.name,
-    description: t.function.description,
-    parameters: t.function.parameters
-  }));
+  });
 }
 
 // src/adapters/base.ts
@@ -2596,7 +2579,7 @@ function messageToGeminiContent(msg) {
     parts
   };
 }
-function formatToolsForGemini2(actions) {
+function formatToolsForGemini(actions) {
   if (!actions || actions.length === 0) return void 0;
   return {
     functionDeclarations: actions.map((action) => ({
@@ -2682,7 +2665,7 @@ var GoogleAdapter = class {
         mergedContents.push({ ...content, parts: [...content.parts] });
       }
     }
-    const tools = formatToolsForGemini2(request.actions);
+    const tools = formatToolsForGemini(request.actions);
     const messageId = core.generateMessageId();
     yield { type: "message:start", id: messageId };
     try {
@@ -2788,7 +2771,7 @@ var GoogleAdapter = class {
         mergedContents.push({ ...content, parts: [...content.parts] });
       }
     }
-    const tools = formatToolsForGemini2(request.actions);
+    const tools = formatToolsForGemini(request.actions);
     const chat = model.startChat({
       history: mergedContents.slice(0, -1),
       systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,