@lupaflow/providers 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name":  "@lupaflow/providers",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/core":  "workspace:*",
+                         "@lupaflow/secrets":  "workspace:*",
+                         "@lupaflow/types":  "workspace:*",
+                         "openai":  "^4.68.0",
+                         "@google/generative-ai":  "^0.21.0"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/google.ts

@@ -0,0 +1,193 @@
+import { GoogleGenerativeAI } from "@google/generative-ai"
+import type { LLMProvider } from "./interface"
+import type { CompletionRequest, CompletionResponse, StreamChunk, ProviderConfig } from "@lupaflow/types"
+import { ProviderError } from "@lupaflow/core"
+import { getGoogleKey } from "@lupaflow/secrets"
+import { globalEventBus } from "@lupaflow/core"
+
+export class GoogleProvider implements LLMProvider {
+  readonly name = "google"
+  readonly defaultModel = "gemini-1.5-flash"
+  config: ProviderConfig
+
+  private client: GoogleGenerativeAI
+
+  constructor(config: ProviderConfig = {}) {
+    this.config = config
+    this.client = new GoogleGenerativeAI(config.apiKey || getGoogleKey())
+  }
+
+  validateConfig(): boolean {
+    try {
+      getGoogleKey()
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  private buildContents(request: CompletionRequest): { role: string; parts: { text: string }[] }[] {
+    const contents: { role: string; parts: { text: string }[] }[] = []
+    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: CompletionRequest): Promise<CompletionResponse> {
+    const start = Date.now()
+    const model = request.model || this.config.model || this.defaultModel
+
+    await globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model,
+    } as any)
+
+    try {
+      const genModel = this.client.getGenerativeModel({ model })
+
+      const systemInstruction = request.systemPrompt
+      const contents = this.buildContents(request)
+
+      const requestOptions: any = {
+        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: any = response.usageMetadata || {}
+      const totalTokens = (usage.promptTokenCount || 0) + (usage.candidatesTokenCount || 0)
+
+      const completionResponse: CompletionResponse = {
+        content: text,
+        toolCalls: [],
+        usage: {
+          promptTokens: usage.promptTokenCount || 0,
+          completionTokens: usage.candidatesTokenCount || 0,
+          totalTokens,
+        },
+        model,
+        latencyMs,
+        finishReason: "stop",
+      }
+
+      await globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: totalTokens,
+        latencyMs,
+      } as any)
+
+      return completionResponse
+    } catch (err: any) {
+      const latencyMs = Date.now() - start
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message,
+      } as any)
+      throw new ProviderError(this.name, err.message, { model, latencyMs })
+    }
+  }
+
+  async *streamComplete(request: CompletionRequest): AsyncIterable<StreamChunk> {
+    const start = Date.now()
+    const model = request.model || this.config.model || this.defaultModel
+
+    await globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model,
+    } as any)
+
+    try {
+      const genModel = this.client.getGenerativeModel({ model })
+
+      const systemInstruction = request.systemPrompt
+      const contents = this.buildContents(request)
+
+      const requestOptions: any = {
+        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: any = 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 globalEventBus.emit("provider:complete", {
+        provider: this.name,
+        model,
+        tokens: totalTokens,
+        latencyMs: Date.now() - start,
+      } as any)
+    } catch (err: any) {
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message,
+      } as any)
+      throw new ProviderError(this.name, err.message, { model, latencyMs: Date.now() - start })
+    }
+  }
+
+  async getModels(): Promise<string[]> {
+    return ["gemini-1.5-flash", "gemini-1.5-pro", "gemini-2.0-flash-exp"]
+  }
+}

package/src/groq.ts

@@ -0,0 +1,235 @@
+import OpenAI from "openai"
+import type { LLMProvider } from "./interface"
+import type { CompletionRequest, CompletionResponse, StreamChunk, ProviderConfig } from "@lupaflow/types"
+import { ProviderError } from "@lupaflow/core"
+import { getGroqKey } from "@lupaflow/secrets"
+import { globalEventBus } from "@lupaflow/core"
+
+export class GroqProvider implements LLMProvider {
+  readonly name = "groq"
+  readonly defaultModel = "llama-3.3-70b-versatile"
+  config: ProviderConfig
+
+  private client: OpenAI
+
+  constructor(config: ProviderConfig = {}) {
+    this.config = config
+    this.client = new OpenAI({
+      apiKey: config.apiKey || getGroqKey(),
+      baseURL: config.baseUrl || "https://api.groq.com/openai/v1",
+    })
+  }
+
+  validateConfig(): boolean {
+    try {
+      getGroqKey()
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  private buildMessages(request: CompletionRequest): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const messages: OpenAI.Chat.ChatCompletionMessageParam[] = []
+    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 as string | null,
+          tool_calls: m.toolCalls as any,
+        })
+      } else if (m.role === "tool") {
+        messages.push({
+          role: "tool",
+          tool_call_id: m.toolCallId || "",
+          content: m.content || "",
+        })
+      } else {
+        messages.push({ role: m.role as any, content: m.content })
+      }
+    }
+    return messages
+  }
+
+  private buildTools(
+    tools?: CompletionRequest["tools"]
+  ): OpenAI.Chat.ChatCompletionTool[] | undefined {
+    return tools?.map((t) => ({
+      type: "function" as const,
+      function: {
+        name: t.definition.name,
+        description: t.definition.description,
+        parameters: {
+          type: "object",
+          properties: t.definition.parameters,
+          required: t.definition.required,
+        },
+      },
+    }))
+  }
+
+  async complete(request: CompletionRequest): Promise<CompletionResponse> {
+    const start = Date.now()
+    const model = request.model || this.config.model || this.defaultModel
+
+    await globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model,
+    } as any)
+
+    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: CompletionResponse = {
+        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,
+      } as any)
+
+      return result
+    } catch (err: any) {
+      const latencyMs = Date.now() - start
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message,
+      } as any)
+      throw new ProviderError(this.name, err.message, { model, latencyMs })
+    }
+  }
+
+  async *streamComplete(request: CompletionRequest): AsyncIterable<StreamChunk> {
+    const start = Date.now()
+    const model = request.model || this.config.model || this.defaultModel
+
+    await globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model,
+    } as any)
+
+    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 = new Map<number, { id: string; name: string; args: string }>()
+
+      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,
+      } as any)
+    } catch (err: any) {
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message,
+      } as any)
+      throw new ProviderError(this.name, err.message, { model, latencyMs: Date.now() - start })
+    }
+  }
+
+  async getModels(): Promise<string[]> {
+    try {
+      const response = await fetch("https://api.groq.com/openai/v1/models", {
+        headers: {
+          Authorization: `Bearer ${getGroqKey()}`,
+        },
+      })
+      const data: any = await response.json()
+      return data.data?.map((m: any) => m.id) || []
+    } catch {
+      return [this.defaultModel]
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+import { providerRegistry } from "./registry"
+import { OpenRouterProvider } from "./openrouter"
+import { GoogleProvider } from "./google"
+import { GroqProvider } from "./groq"
+
+providerRegistry.register("openrouter", OpenRouterProvider)
+providerRegistry.register("google", GoogleProvider)
+providerRegistry.register("groq", GroqProvider)
+
+export { providerRegistry }
+export type { LLMProvider } from "./interface"
+export { OpenRouterProvider } from "./openrouter"
+export { GoogleProvider } from "./google"
+export { GroqProvider } from "./groq"

package/src/interface.ts

@@ -0,0 +1,12 @@
+import type { CompletionRequest, CompletionResponse, StreamChunk, ProviderConfig } from "@lupaflow/types"
+
+export interface LLMProvider {
+  readonly name: string
+  readonly defaultModel: string
+  config: ProviderConfig
+
+  complete(request: CompletionRequest): Promise<CompletionResponse>
+  streamComplete(request: CompletionRequest): AsyncIterable<StreamChunk>
+  getModels?(): Promise<string[]>
+  validateConfig(): boolean
+}

package/src/openrouter.ts

@@ -0,0 +1,235 @@
+import OpenAI from "openai"
+import type { LLMProvider } from "./interface"
+import type { CompletionRequest, CompletionResponse, StreamChunk, ProviderConfig } from "@lupaflow/types"
+import { ProviderError } from "@lupaflow/core"
+import { getOpenRouterKey } from "@lupaflow/secrets"
+import { globalEventBus } from "@lupaflow/core"
+
+export class OpenRouterProvider implements LLMProvider {
+  readonly name = "openrouter"
+  readonly defaultModel = "openai/gpt-4o-mini"
+  config: ProviderConfig
+
+  private client: OpenAI
+
+  constructor(config: ProviderConfig = {}) {
+    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(): boolean {
+    try {
+      getOpenRouterKey()
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  private buildMessages(request: CompletionRequest): OpenAI.Chat.ChatCompletionMessageParam[] {
+    const messages: OpenAI.Chat.ChatCompletionMessageParam[] = []
+    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 as string | null,
+          tool_calls: m.toolCalls as any,
+        })
+      } else if (m.role === "tool") {
+        messages.push({
+          role: "tool",
+          tool_call_id: m.toolCallId || "",
+          content: m.content || "",
+        })
+      } else {
+        messages.push({ role: m.role as any, content: m.content })
+      }
+    }
+    return messages
+  }
+
+  private buildTools(
+    tools?: CompletionRequest["tools"]
+  ): OpenAI.Chat.ChatCompletionTool[] | undefined {
+    return tools?.map((t) => ({
+      type: "function" as const,
+      function: {
+        name: t.definition.name,
+        description: t.definition.description,
+        parameters: {
+          type: "object",
+          properties: t.definition.parameters,
+          required: t.definition.required,
+        },
+      },
+    }))
+  }
+
+  async complete(request: CompletionRequest): Promise<CompletionResponse> {
+    const start = Date.now()
+    const model = request.model || this.config.model || this.defaultModel
+
+    await globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model,
+    } as any)
+
+    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: CompletionResponse = {
+        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,
+      } as any)
+
+      return result
+    } catch (err: any) {
+      const latencyMs = Date.now() - start
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message,
+      } as any)
+      throw new ProviderError(this.name, err.message, { model, latencyMs })
+    }
+  }
+
+  async *streamComplete(request: CompletionRequest): AsyncIterable<StreamChunk> {
+    const start = Date.now()
+    const model = request.model || this.config.model || this.defaultModel
+
+    await globalEventBus.emit("provider:start", {
+      provider: this.name,
+      model,
+    } as any)
+
+    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 = new Map<number, { id: string; name: string; args: string }>()
+
+      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,
+      } as any)
+    } catch (err: any) {
+      await globalEventBus.emit("provider:error", {
+        provider: this.name,
+        model,
+        error: err.message,
+      } as any)
+      throw new ProviderError(this.name, err.message, { model, latencyMs: Date.now() - start })
+    }
+  }
+
+  async getModels(): Promise<string[]> {
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models")
+      const data: any = await response.json()
+      return data.data?.map((m: any) => m.id) || []
+    } catch {
+      return [this.defaultModel]
+    }
+  }
+}

package/src/registry.ts

@@ -0,0 +1,50 @@
+import type { ProviderName, ProviderConfig, CompletionRequest, CompletionResponse, StreamChunk } from "@lupaflow/types"
+import { ConfigError } from "@lupaflow/core"
+
+interface LLMProvider {
+  readonly name: string
+  readonly defaultModel: string
+  config: ProviderConfig
+  complete(request: CompletionRequest): Promise<CompletionResponse>
+  streamComplete(request: CompletionRequest): AsyncIterable<StreamChunk>
+  getModels?(): Promise<string[]>
+  validateConfig(): boolean
+}
+
+class ProviderRegistry {
+  private providers: Map<ProviderName, new (config: ProviderConfig) => LLMProvider> = new Map()
+  private instances: Map<ProviderName, LLMProvider> = new Map()
+
+  register(name: ProviderName, ctor: new (config: ProviderConfig) => LLMProvider): void {
+    this.providers.set(name, ctor)
+  }
+
+  get(name: ProviderName, config?: ProviderConfig): LLMProvider {
+    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: string): name is ProviderName {
+    return this.providers.has(name as ProviderName)
+  }
+
+  list(): ProviderName[] {
+    return Array.from(this.providers.keys())
+  }
+}
+
+export const providerRegistry = new ProviderRegistry()

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})