@lupaflow/providers 0.1.1 → 0.1.2

package/dist/index.js

@@ -0,0 +1,617 @@
+// src/registry.ts
+import { ConfigError } from "@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 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
+import OpenAI from "openai";
+import { ProviderError } from "@lupaflow/core";
+import { getOpenRouterKey } from "@lupaflow/secrets";
+import { globalEventBus } from "@lupaflow/core";
+var OpenRouterProvider = class {
+  name = "openrouter";
+  defaultModel = "openai/gpt-4o-mini";
+  config;
+  client;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new OpenAI({
+      apiKey: config.apiKey || getOpenRouterKey(),
+      baseURL: config.baseUrl || "https://openrouter.ai/api/v1",
+      defaultHeaders: {
+        "HTTP-Referer": "https://lupaflow.dev",
+        "X-Title": "LupaFlow"
+      }
+    });
+  }
+  validateConfig() {
+    try {
+      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 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 globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: result.usage.totalTokens,
+        latencyMs
+      });
+      return result;
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new ProviderError(this.name, err.message, { model, latencyMs });
+    }
+  }
+  async *streamComplete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await 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 globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: 0,
+        latencyMs: Date.now() - start
+      });
+    } catch (err) {
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new 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
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { ProviderError as ProviderError2 } from "@lupaflow/core";
+import { getGoogleKey } from "@lupaflow/secrets";
+import { globalEventBus as globalEventBus2 } from "@lupaflow/core";
+var GoogleProvider = class {
+  name = "google";
+  defaultModel = "gemini-1.5-flash";
+  config;
+  client;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new GoogleGenerativeAI(config.apiKey || getGoogleKey());
+  }
+  validateConfig() {
+    try {
+      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 globalEventBus2.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 globalEventBus2.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: totalTokens,
+        latencyMs
+      });
+      return completionResponse;
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      await globalEventBus2.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new ProviderError2(this.name, err.message, { model, latencyMs });
+    }
+  }
+  async *streamComplete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await globalEventBus2.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 globalEventBus2.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: totalTokens,
+        latencyMs: Date.now() - start
+      });
+    } catch (err) {
+      await globalEventBus2.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new ProviderError2(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
+import OpenAI2 from "openai";
+import { ProviderError as ProviderError3 } from "@lupaflow/core";
+import { getGroqKey } from "@lupaflow/secrets";
+import { globalEventBus as globalEventBus3 } from "@lupaflow/core";
+var GroqProvider = class {
+  name = "groq";
+  defaultModel = "llama-3.3-70b-versatile";
+  config;
+  client;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new OpenAI2({
+      apiKey: config.apiKey || getGroqKey(),
+      baseURL: config.baseUrl || "https://api.groq.com/openai/v1"
+    });
+  }
+  validateConfig() {
+    try {
+      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 globalEventBus3.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 globalEventBus3.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: result.usage.totalTokens,
+        latencyMs
+      });
+      return result;
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      await globalEventBus3.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new ProviderError3(this.name, err.message, { model, latencyMs });
+    }
+  }
+  async *streamComplete(request) {
+    const start = Date.now();
+    const model = request.model || this.config.model || this.defaultModel;
+    await globalEventBus3.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 globalEventBus3.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: 0,
+        latencyMs: Date.now() - start
+      });
+    } catch (err) {
+      await globalEventBus3.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message
+      });
+      throw new ProviderError3(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 ${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);
+export {
+  GoogleProvider,
+  GroqProvider,
+  OpenRouterProvider,
+  providerRegistry
+};
+//# sourceMappingURL=index.js.map