@lupaflow/providers 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,657 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GoogleProvider: () => GoogleProvider,
+  GroqProvider: () => GroqProvider,
+  OpenRouterProvider: () => OpenRouterProvider,
+  providerRegistry: () => providerRegistry
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/registry.ts
+var import_core = require("@lupaflow/core");
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  register(name, ctor) {
+    this.providers.set(name, ctor);
+  }
+  get(name, config) {
+    if (!config && this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+    const ctor = this.providers.get(name);
+    if (!ctor) {
+      throw new import_core.ConfigError(`Unknown provider: "${name}"`, {
+        available: Array.from(this.providers.keys())
+      });
+    }
+    const instance = new ctor(config || {});
+    if (!config) {
+      this.instances.set(name, instance);
+    }
+    return instance;
+  }
+  has(name) {
+    return this.providers.has(name);
+  }
+  list() {
+    return Array.from(this.providers.keys());
+  }
+};
+var providerRegistry = new ProviderRegistry();
+
+// src/openrouter.ts
+var import_openai = __toESM(require("openai"), 1);
+var import_core2 = require("@lupaflow/core");
+var import_secrets = require("@lupaflow/secrets");
+var import_core3 = require("@lupaflow/core");
+var OpenRouterProvider = class {
+  name = "openrouter";
+  defaultModel = "openai/gpt-4o-mini";
+  config;
+  client;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new import_openai.default({
+      apiKey: config.apiKey || (0, import_secrets.getOpenRouterKey)(),
+      baseURL: config.baseUrl || "https://openrouter.ai/api/v1",
+      defaultHeaders: {
+        "HTTP-Referer": "https://lupaflow.dev",
+        "X-Title": "LupaFlow"
+      }
+    });
+  }
+  validateConfig() {
+    try {
+      (0, import_secrets.getOpenRouterKey)();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildMessages(request) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      if (m.role === "assistant" && m.toolCalls?.length) {
+        messages.push({
+          role: "assistant",
+          content: m.content,
+          tool_calls: m.toolCalls
+        });
+      } else if (m.role === "tool") {
+        messages.push({
+          role: "tool",
+          tool_call_id: m.toolCallId || "",
+          content: m.content || ""
+        });
+      } else {
+        messages.push({ role: m.role, content: m.content });
+      }
+    }
+    return messages;
+  }
+  buildTools(tools) {
+    return tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.definition.name,
+        description: t.definition.description,
+        parameters: {
+          type: "object",
+          properties: t.definition.parameters,
+          required: t.definition.required
+        }
+      }
+    }));
+  }
+  async complete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await import_core3.globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model
+    });
+    try {
+      const messages = this.buildMessages(request);
+      const tools = this.buildTools(request.tools);
+      const response = await this.client.chat.completions.create({
+        model,
+        messages,
+        tools,
+        temperature: request.temperature ?? this.config.temperature,
+        max_tokens: request.maxTokens ?? this.config.maxTokens,
+        top_p: request.topP ?? this.config.topP
+      });
+      const choice = response.choices[0];
+      const latencyMs = Date.now() - start;
+      const result = {
+        content: choice.message.content,
+        toolCalls: (choice.message.tool_calls || []).map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          args: JSON.parse(tc.function.arguments)
+        })),
+        usage: {
+          promptTokens: response.usage?.prompt_tokens || 0,
+          completionTokens: response.usage?.completion_tokens || 0,
+          totalTokens: response.usage?.total_tokens || 0
+        },
+        model: response.model,
+        latencyMs,
+        finishReason: choice.finish_reason || "stop"
+      };
+      await import_core3.globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: result.usage.totalTokens,
+        latencyMs
+      });
+      return result;
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      await import_core3.globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new import_core2.ProviderError(this.name, err.message, { model, latencyMs });
+    }
+  }
+  async *streamComplete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await import_core3.globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model
+    });
+    try {
+      const messages = this.buildMessages(request);
+      const tools = this.buildTools(request.tools);
+      const stream = await this.client.chat.completions.create({
+        model,
+        messages,
+        tools,
+        temperature: request.temperature ?? this.config.temperature,
+        max_tokens: request.maxTokens ?? this.config.maxTokens,
+        top_p: request.topP ?? this.config.topP,
+        stream: true
+      });
+      let fullContent = "";
+      const accToolCalls = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          fullContent += delta.content;
+          yield { type: "text", text: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (!accToolCalls.has(tc.index)) {
+              accToolCalls.set(tc.index, { id: "", name: "", args: "" });
+            }
+            const entry = accToolCalls.get(tc.index);
+            if (tc.id) entry.id = tc.id;
+            if (tc.function?.name) entry.name = tc.function.name;
+            if (tc.function?.arguments) entry.args += tc.function.arguments;
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          const finishReason = chunk.choices[0].finish_reason;
+          const toolCalls = Array.from(accToolCalls.values()).filter((tc) => tc.id && tc.name).map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            args: JSON.parse(tc.args || "{}")
+          }));
+          yield {
+            type: "finish",
+            content: fullContent,
+            toolCalls,
+            usage: {
+              promptTokens: chunk.usage?.prompt_tokens || 0,
+              completionTokens: chunk.usage?.completion_tokens || 0,
+              totalTokens: chunk.usage?.total_tokens || 0
+            },
+            model,
+            finishReason
+          };
+        }
+      }
+      await import_core3.globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: 0,
+        latencyMs: Date.now() - start
+      });
+    } catch (err) {
+      await import_core3.globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new import_core2.ProviderError(this.name, err.message, { model, latencyMs: Date.now() - start });
+    }
+  }
+  async getModels() {
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models");
+      const data = await response.json();
+      return data.data?.map((m) => m.id) || [];
+    } catch {
+      return [this.defaultModel];
+    }
+  }
+};
+
+// src/google.ts
+var import_generative_ai = require("@google/generative-ai");
+var import_core4 = require("@lupaflow/core");
+var import_secrets2 = require("@lupaflow/secrets");
+var import_core5 = require("@lupaflow/core");
+var GoogleProvider = class {
+  name = "google";
+  defaultModel = "gemini-1.5-flash";
+  config;
+  client;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new import_generative_ai.GoogleGenerativeAI(config.apiKey || (0, import_secrets2.getGoogleKey)());
+  }
+  validateConfig() {
+    try {
+      (0, import_secrets2.getGoogleKey)();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildContents(request) {
+    const contents = [];
+    for (const msg of request.messages) {
+      if (msg.role === "system") continue;
+      const role = msg.role === "assistant" ? "model" : "user";
+      contents.push({
+        role,
+        parts: [{ text: msg.content || "" }]
+      });
+    }
+    return contents;
+  }
+  async complete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await import_core5.globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model
+    });
+    try {
+      const genModel = this.client.getGenerativeModel({ model });
+      const systemInstruction = request.systemPrompt;
+      const contents = this.buildContents(request);
+      const requestOptions = {
+        contents,
+        generationConfig: {
+          temperature: request.temperature ?? this.config.temperature,
+          maxOutputTokens: request.maxTokens ?? this.config.maxTokens,
+          topP: request.topP ?? this.config.topP
+        }
+      };
+      if (systemInstruction) {
+        requestOptions.systemInstruction = {
+          role: "user",
+          parts: [{ text: systemInstruction }]
+        };
+      }
+      const result = await genModel.generateContent(requestOptions);
+      const latencyMs = Date.now() - start;
+      const response = result.response;
+      const text = response.text();
+      const usage = response.usageMetadata || {};
+      const totalTokens = (usage.promptTokenCount || 0) + (usage.candidatesTokenCount || 0);
+      const completionResponse = {
+        content: text,
+        toolCalls: [],
+        usage: {
+          promptTokens: usage.promptTokenCount || 0,
+          completionTokens: usage.candidatesTokenCount || 0,
+          totalTokens
+        },
+        model,
+        latencyMs,
+        finishReason: "stop"
+      };
+      await import_core5.globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: totalTokens,
+        latencyMs
+      });
+      return completionResponse;
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      await import_core5.globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new import_core4.ProviderError(this.name, err.message, { model, latencyMs });
+    }
+  }
+  async *streamComplete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await import_core5.globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model
+    });
+    try {
+      const genModel = this.client.getGenerativeModel({ model });
+      const systemInstruction = request.systemPrompt;
+      const contents = this.buildContents(request);
+      const requestOptions = {
+        contents,
+        generationConfig: {
+          temperature: request.temperature ?? this.config.temperature,
+          maxOutputTokens: request.maxTokens ?? this.config.maxTokens,
+          topP: request.topP ?? this.config.topP
+        }
+      };
+      if (systemInstruction) {
+        requestOptions.systemInstruction = {
+          role: "user",
+          parts: [{ text: systemInstruction }]
+        };
+      }
+      const result = await genModel.generateContentStream(requestOptions);
+      let fullContent = "";
+      for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text) {
+          fullContent += text;
+          yield { type: "text", text };
+        }
+      }
+      const response = await result.response;
+      const usage = response.usageMetadata || {};
+      const totalTokens = (usage.promptTokenCount || 0) + (usage.candidatesTokenCount || 0);
+      yield {
+        type: "finish",
+        content: fullContent,
+        toolCalls: [],
+        usage: {
+          promptTokens: usage.promptTokenCount || 0,
+          completionTokens: usage.candidatesTokenCount || 0,
+          totalTokens
+        },
+        model,
+        finishReason: "stop"
+      };
+      await import_core5.globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: totalTokens,
+        latencyMs: Date.now() - start
+      });
+    } catch (err) {
+      await import_core5.globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new import_core4.ProviderError(this.name, err.message, { model, latencyMs: Date.now() - start });
+    }
+  }
+  async getModels() {
+    return ["gemini-1.5-flash", "gemini-1.5-pro", "gemini-2.0-flash-exp"];
+  }
+};
+
+// src/groq.ts
+var import_openai2 = __toESM(require("openai"), 1);
+var import_core6 = require("@lupaflow/core");
+var import_secrets3 = require("@lupaflow/secrets");
+var import_core7 = require("@lupaflow/core");
+var GroqProvider = class {
+  name = "groq";
+  defaultModel = "llama-3.3-70b-versatile";
+  config;
+  client;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new import_openai2.default({
+      apiKey: config.apiKey || (0, import_secrets3.getGroqKey)(),
+      baseURL: config.baseUrl || "https://api.groq.com/openai/v1"
+    });
+  }
+  validateConfig() {
+    try {
+      (0, import_secrets3.getGroqKey)();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildMessages(request) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      if (m.role === "assistant" && m.toolCalls?.length) {
+        messages.push({
+          role: "assistant",
+          content: m.content,
+          tool_calls: m.toolCalls
+        });
+      } else if (m.role === "tool") {
+        messages.push({
+          role: "tool",
+          tool_call_id: m.toolCallId || "",
+          content: m.content || ""
+        });
+      } else {
+        messages.push({ role: m.role, content: m.content });
+      }
+    }
+    return messages;
+  }
+  buildTools(tools) {
+    return tools?.map((t) => ({
+      type: "function",
+      function: {
+        name: t.definition.name,
+        description: t.definition.description,
+        parameters: {
+          type: "object",
+          properties: t.definition.parameters,
+          required: t.definition.required
+        }
+      }
+    }));
+  }
+  async complete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await import_core7.globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model
+    });
+    try {
+      const messages = this.buildMessages(request);
+      const tools = this.buildTools(request.tools);
+      const response = await this.client.chat.completions.create({
+        model,
+        messages,
+        tools,
+        temperature: request.temperature ?? this.config.temperature,
+        max_tokens: request.maxTokens ?? this.config.maxTokens,
+        top_p: request.topP ?? this.config.topP
+      });
+      const choice = response.choices[0];
+      const latencyMs = Date.now() - start;
+      const result = {
+        content: choice.message.content,
+        toolCalls: (choice.message.tool_calls || []).map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          args: JSON.parse(tc.function.arguments)
+        })),
+        usage: {
+          promptTokens: response.usage?.prompt_tokens || 0,
+          completionTokens: response.usage?.completion_tokens || 0,
+          totalTokens: response.usage?.total_tokens || 0
+        },
+        model: response.model,
+        latencyMs,
+        finishReason: choice.finish_reason || "stop"
+      };
+      await import_core7.globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: result.usage.totalTokens,
+        latencyMs
+      });
+      return result;
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      await import_core7.globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new import_core6.ProviderError(this.name, err.message, { model, latencyMs });
+    }
+  }
+  async *streamComplete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await import_core7.globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model
+    });
+    try {
+      const messages = this.buildMessages(request);
+      const tools = this.buildTools(request.tools);
+      const stream = await this.client.chat.completions.create({
+        model,
+        messages,
+        tools,
+        temperature: request.temperature ?? this.config.temperature,
+        max_tokens: request.maxTokens ?? this.config.maxTokens,
+        top_p: request.topP ?? this.config.topP,
+        stream: true
+      });
+      let fullContent = "";
+      const accToolCalls = /* @__PURE__ */ new Map();
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          fullContent += delta.content;
+          yield { type: "text", text: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (!accToolCalls.has(tc.index)) {
+              accToolCalls.set(tc.index, { id: "", name: "", args: "" });
+            }
+            const entry = accToolCalls.get(tc.index);
+            if (tc.id) entry.id = tc.id;
+            if (tc.function?.name) entry.name = tc.function.name;
+            if (tc.function?.arguments) entry.args += tc.function.arguments;
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          const finishReason = chunk.choices[0].finish_reason;
+          const toolCalls = Array.from(accToolCalls.values()).filter((tc) => tc.id && tc.name).map((tc) => ({
+            id: tc.id,
+            name: tc.name,
+            args: JSON.parse(tc.args || "{}")
+          }));
+          yield {
+            type: "finish",
+            content: fullContent,
+            toolCalls,
+            usage: {
+              promptTokens: chunk.usage?.prompt_tokens || 0,
+              completionTokens: chunk.usage?.completion_tokens || 0,
+              totalTokens: chunk.usage?.total_tokens || 0
+            },
+            model,
+            finishReason
+          };
+        }
+      }
+      await import_core7.globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: 0,
+        latencyMs: Date.now() - start
+      });
+    } catch (err) {
+      await import_core7.globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new import_core6.ProviderError(this.name, err.message, { model, latencyMs: Date.now() - start });
+    }
+  }
+  async getModels() {
+    try {
+      const response = await fetch("https://api.groq.com/openai/v1/models", {
+        headers: {
+          Authorization: `Bearer ${(0, import_secrets3.getGroqKey)()}`
+        }
+      });
+      const data = await response.json();
+      return data.data?.map((m) => m.id) || [];
+    } catch {
+      return [this.defaultModel];
+    }
+  }
+};
+
+// src/index.ts
+providerRegistry.register("openrouter", OpenRouterProvider);
+providerRegistry.register("google", GoogleProvider);
+providerRegistry.register("groq", GroqProvider);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GoogleProvider,
+  GroqProvider,
+  OpenRouterProvider,
+  providerRegistry
+});
+//# sourceMappingURL=index.cjs.map