@yourgpt/llm-sdk 0.1.0 → 1.0.0

package/dist/providers/google/index.js

@@ -0,0 +1,790 @@
+'use strict';
+
+var core = require('@yourgpt/copilot-sdk/core');
+
+// src/providers/google/provider.ts
+var GOOGLE_MODELS = {
+  // Gemini 2.0
+  "gemini-2.0-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-2.0-flash-exp": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-2.0-flash-thinking-exp": {
+    vision: true,
+    tools: false,
+    audio: false,
+    video: false,
+    maxTokens: 32767
+  },
+  // Gemini 1.5
+  "gemini-1.5-pro": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 2097152
+  },
+  "gemini-1.5-pro-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 2097152
+  },
+  "gemini-1.5-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-1.5-flash-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-1.5-flash-8b": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    maxTokens: 1048576
+  }
+};
+function google(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { GoogleGenerativeAI } = await import('@google/generative-ai');
+      client = new GoogleGenerativeAI(apiKey);
+    }
+    return client;
+  }
+  const modelConfig = GOOGLE_MODELS[modelId] ?? GOOGLE_MODELS["gemini-2.0-flash"];
+  return {
+    provider: "google",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsThinking: modelId.includes("thinking"),
+      supportsPDF: true,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      const client2 = await getClient();
+      const model = client2.getGenerativeModel({
+        model: modelId,
+        safetySettings: options.safetySettings
+      });
+      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
+        }
+      });
+      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,
+        toolCalls,
+        finishReason: mapFinishReason(candidate?.finishReason),
+        usage: {
+          promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
+          completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+          totalTokens: response.usageMetadata?.totalTokenCount ?? 0
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      const client2 = await getClient();
+      const model = client2.getGenerativeModel({
+        model: modelId,
+        safetySettings: options.safetySettings
+      });
+      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
+        }
+      });
+      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 || {}
+                }
+              };
+            }
+          }
+          if (chunk.usageMetadata) {
+            promptTokens = chunk.usageMetadata.promptTokenCount ?? 0;
+            completionTokens = chunk.usageMetadata.candidatesTokenCount ?? 0;
+          }
+          if (candidate.finishReason) {
+            yield {
+              type: "finish",
+              finishReason: mapFinishReason(candidate.finishReason),
+              usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens
+              }
+            };
+          }
+        }
+      } catch (error) {
+        yield {
+          type: "error",
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    }
+  };
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+      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
+              }
+            });
+          }
+        }
+      }
+      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: {
+              name: tc.name,
+              args: 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 { systemInstruction, contents: merged };
+}
+function formatToolsForGemini(tools) {
+  return tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    parameters: t.function.parameters
+  }));
+}
+function attachmentToGeminiPart(attachment) {
+  if (!attachment.data) {
+    console.warn(
+      "Gemini adapter: URL-based attachments not supported, skipping"
+    );
+    return null;
+  }
+  if (attachment.type === "image") {
+    let base64Data = attachment.data;
+    if (base64Data.startsWith("data:")) {
+      const commaIndex = base64Data.indexOf(",");
+      if (commaIndex !== -1) {
+        base64Data = base64Data.slice(commaIndex + 1);
+      }
+    }
+    return {
+      inlineData: {
+        mimeType: attachment.mimeType || "image/png",
+        data: base64Data
+      }
+    };
+  }
+  if (attachment.type === "audio" || attachment.type === "video") {
+    let base64Data = attachment.data;
+    if (base64Data.startsWith("data:")) {
+      const commaIndex = base64Data.indexOf(",");
+      if (commaIndex !== -1) {
+        base64Data = base64Data.slice(commaIndex + 1);
+      }
+    }
+    return {
+      inlineData: {
+        mimeType: attachment.mimeType || (attachment.type === "audio" ? "audio/mp3" : "video/mp4"),
+        data: base64Data
+      }
+    };
+  }
+  return null;
+}
+function messageToGeminiContent(msg) {
+  if (msg.role === "system") return null;
+  const parts = [];
+  if (msg.role === "tool" && msg.tool_call_id) {
+    let responseData;
+    try {
+      responseData = JSON.parse(msg.content || "{}");
+    } catch {
+      responseData = { result: msg.content || "" };
+    }
+    const toolName = msg.metadata?.toolName || "tool";
+    parts.push({
+      functionResponse: {
+        name: toolName,
+        response: responseData
+      }
+    });
+    return { role: "user", parts };
+  }
+  if (msg.content) {
+    parts.push({ text: msg.content });
+  }
+  const attachments = msg.metadata?.attachments;
+  if (attachments && Array.isArray(attachments)) {
+    for (const attachment of attachments) {
+      const part = attachmentToGeminiPart(attachment);
+      if (part) {
+        parts.push(part);
+      }
+    }
+  }
+  if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+    for (const tc of msg.tool_calls) {
+      let args = {};
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch {
+      }
+      parts.push({
+        functionCall: {
+          name: tc.function.name,
+          args
+        }
+      });
+    }
+  }
+  if (parts.length === 0) return null;
+  return {
+    role: msg.role === "assistant" ? "model" : "user",
+    parts
+  };
+}
+function formatToolsForGemini2(actions) {
+  if (!actions || actions.length === 0) return void 0;
+  return {
+    functionDeclarations: actions.map((action) => ({
+      name: action.name,
+      description: action.description,
+      parameters: action.parameters ? {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            {
+              type: param.type,
+              description: param.description,
+              enum: param.enum
+            }
+          ])
+        ),
+        required: Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key)
+      } : void 0
+    }))
+  };
+}
+var GoogleAdapter = class {
+  constructor(config) {
+    this.provider = "google";
+    this.config = config;
+    this.model = config.model || "gemini-2.0-flash";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { GoogleGenerativeAI } = await import('@google/generative-ai');
+      this.client = new GoogleGenerativeAI(this.config.apiKey);
+    }
+    return this.client;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    const modelId = request.config?.model || this.model;
+    const model = client.getGenerativeModel({
+      model: modelId,
+      safetySettings: this.config.safetySettings
+    });
+    let contents = [];
+    let systemInstruction;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      for (const msg of request.rawMessages) {
+        if (msg.role === "system") {
+          systemInstruction = (systemInstruction || "") + (msg.content || "");
+          continue;
+        }
+        const content = messageToGeminiContent(msg);
+        if (content) {
+          contents.push(content);
+        }
+      }
+      if (request.systemPrompt && !systemInstruction) {
+        systemInstruction = request.systemPrompt;
+      }
+    } else {
+      for (const msg of request.messages) {
+        if (msg.role === "system") {
+          systemInstruction = (systemInstruction || "") + (msg.content || "");
+          continue;
+        }
+        const content = messageToGeminiContent(msg);
+        if (content) {
+          contents.push(content);
+        }
+      }
+      if (request.systemPrompt) {
+        systemInstruction = request.systemPrompt;
+      }
+    }
+    if (contents.length === 0 || contents[0].role !== "user") {
+      contents = [{ role: "user", parts: [{ text: "" }] }, ...contents];
+    }
+    const mergedContents = [];
+    for (const content of contents) {
+      const last = mergedContents[mergedContents.length - 1];
+      if (last && last.role === content.role) {
+        last.parts.push(...content.parts);
+      } else {
+        mergedContents.push({ ...content, parts: [...content.parts] });
+      }
+    }
+    const tools = formatToolsForGemini2(request.actions);
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const chat = model.startChat({
+        history: mergedContents.slice(0, -1),
+        // All but the last message
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+        tools: tools ? [tools] : void 0,
+        generationConfig: {
+          temperature: request.config?.temperature ?? this.config.temperature,
+          maxOutputTokens: request.config?.maxTokens ?? this.config.maxTokens
+        }
+      });
+      const lastMessage = mergedContents[mergedContents.length - 1];
+      const result = await chat.sendMessageStream(lastMessage.parts);
+      let currentToolCall = null;
+      for await (const chunk of result.stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        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: "message:delta", content: part.text };
+          }
+          if ("functionCall" in part && part.functionCall) {
+            const fc = part.functionCall;
+            const toolId = core.generateToolCallId();
+            if (currentToolCall) {
+              yield {
+                type: "action:args",
+                id: currentToolCall.id,
+                args: JSON.stringify(currentToolCall.args)
+              };
+            }
+            currentToolCall = {
+              id: toolId,
+              name: fc.name,
+              args: fc.args || {}
+            };
+            yield {
+              type: "action:start",
+              id: toolId,
+              name: fc.name
+            };
+          }
+        }
+        if (candidate.finishReason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: JSON.stringify(currentToolCall.args)
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "GOOGLE_ERROR"
+      };
+    }
+  }
+  /**
+   * Non-streaming completion (optional, for debugging)
+   */
+  async complete(request) {
+    const client = await this.getClient();
+    const modelId = request.config?.model || this.model;
+    const model = client.getGenerativeModel({
+      model: modelId,
+      safetySettings: this.config.safetySettings
+    });
+    let contents = [];
+    let systemInstruction;
+    for (const msg of request.messages) {
+      if (msg.role === "system") {
+        systemInstruction = (systemInstruction || "") + (msg.content || "");
+        continue;
+      }
+      const content = messageToGeminiContent(msg);
+      if (content) {
+        contents.push(content);
+      }
+    }
+    if (request.systemPrompt) {
+      systemInstruction = request.systemPrompt;
+    }
+    if (contents.length === 0 || contents[0].role !== "user") {
+      contents = [{ role: "user", parts: [{ text: "" }] }, ...contents];
+    }
+    const mergedContents = [];
+    for (const content of contents) {
+      const last = mergedContents[mergedContents.length - 1];
+      if (last && last.role === content.role) {
+        last.parts.push(...content.parts);
+      } else {
+        mergedContents.push({ ...content, parts: [...content.parts] });
+      }
+    }
+    const tools = formatToolsForGemini2(request.actions);
+    const chat = model.startChat({
+      history: mergedContents.slice(0, -1),
+      systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+      tools: tools ? [tools] : void 0,
+      generationConfig: {
+        temperature: request.config?.temperature ?? this.config.temperature,
+        maxOutputTokens: request.config?.maxTokens ?? this.config.maxTokens
+      }
+    });
+    const lastMessage = mergedContents[mergedContents.length - 1];
+    const result = await chat.sendMessage(lastMessage.parts);
+    const response = result.response;
+    let textContent = "";
+    const toolCalls = [];
+    const candidate = response.candidates?.[0];
+    if (candidate?.content?.parts) {
+      for (const part of candidate.content.parts) {
+        if ("text" in part && part.text) {
+          textContent += part.text;
+        }
+        if ("functionCall" in part && part.functionCall) {
+          toolCalls.push({
+            id: core.generateToolCallId(),
+            name: part.functionCall.name,
+            args: part.functionCall.args || {}
+          });
+        }
+      }
+    }
+    return {
+      content: textContent,
+      toolCalls,
+      rawResponse: response
+    };
+  }
+};
+function createGoogleAdapter(config) {
+  return new GoogleAdapter(config);
+}
+
+// src/providers/google/index.ts
+var GOOGLE_MODELS2 = {
+  // Gemini 2.0 series (latest)
+  "gemini-2.0-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  "gemini-2.0-flash-lite": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  // Gemini 2.5 series (experimental)
+  "gemini-2.5-pro-preview-05-06": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 65536
+  },
+  "gemini-2.5-flash-preview-05-20": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 65536
+  },
+  // Gemini 1.5 series
+  "gemini-1.5-pro": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 2e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-pro-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 2e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-flash-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-flash-8b": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  // Gemini 1.0 series (legacy)
+  "gemini-1.0-pro": {
+    vision: false,
+    tools: true,
+    audio: false,
+    video: false,
+    pdf: false,
+    maxTokens: 30720,
+    outputTokens: 2048
+  }
+};
+function createGoogle(config = {}) {
+  const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? "";
+  return {
+    name: "google",
+    supportedModels: Object.keys(GOOGLE_MODELS2),
+    languageModel(modelId) {
+      return createGoogleAdapter({
+        apiKey,
+        model: modelId,
+        baseUrl: config.baseUrl,
+        safetySettings: config.safetySettings
+      });
+    },
+    getCapabilities(modelId) {
+      const model = GOOGLE_MODELS2[modelId] ?? GOOGLE_MODELS2["gemini-2.0-flash"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        // Gemini doesn't have extended thinking like Claude
+        supportsStreaming: true,
+        supportsPDF: model.pdf,
+        supportsAudio: model.audio,
+        supportsVideo: model.video,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? [
+          "image/png",
+          "image/jpeg",
+          "image/gif",
+          "image/webp",
+          "image/heic",
+          "image/heif"
+        ] : [],
+        supportedAudioTypes: model.audio ? [
+          "audio/mp3",
+          "audio/wav",
+          "audio/aiff",
+          "audio/aac",
+          "audio/ogg",
+          "audio/flac"
+        ] : [],
+        supportedVideoTypes: model.video ? [
+          "video/mp4",
+          "video/mpeg",
+          "video/mov",
+          "video/avi",
+          "video/webm",
+          "video/mkv"
+        ] : [],
+        supportsJsonMode: true,
+        // Gemini supports JSON mode
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+var createGoogleProvider = createGoogle;
+
+exports.createGoogle = createGoogle;
+exports.createGoogleModel = google;
+exports.createGoogleProvider = createGoogleProvider;
+exports.google = google;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map