vargai 0.3.0

package/src/providers/fireworks.ts

@@ -0,0 +1,193 @@
+/**
+ * Fireworks.ai provider for audio transcription with word-level timestamps
+ * Supports Whisper models with advanced features like diarization and VAD
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import type { JobStatusUpdate, ProviderConfig } from "../core/schema/types";
+import { BaseProvider } from "./base";
+
+// Types
+export interface FireworksWord {
+  word: string;
+  language: string;
+  probability: number;
+  hallucination_score: number;
+  start: number;
+  end: number;
+  retry_count: number;
+}
+
+export interface FireworksResponse {
+  task: string;
+  language: string;
+  text: string;
+  request_id: string;
+  words: FireworksWord[];
+  duration: number;
+}
+
+export class FireworksProvider extends BaseProvider {
+  readonly name = "fireworks";
+
+  async submit(
+    _model: string,
+    _inputs: Record<string, unknown>,
+    _config?: ProviderConfig,
+  ): Promise<string> {
+    const jobId = `fw_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    console.log(`[fireworks] starting transcription: ${jobId}`);
+    return jobId;
+  }
+
+  async getStatus(_jobId: string): Promise<JobStatusUpdate> {
+    return { status: "completed" };
+  }
+
+  async getResult(_jobId: string): Promise<unknown> {
+    return null;
+  }
+
+  // ============================================================================
+  // High-level convenience methods
+  // ============================================================================
+
+  async transcribe(options: {
+    audioPath: string;
+    vadModel?: "whisperx-pyannet" | "silero";
+    alignmentModel?: "tdnn_ffn" | "wav2vec2";
+    responseFormat?: "json" | "verbose_json" | "text" | "srt" | "vtt";
+    preprocessing?: "none" | "denoise";
+    temperature?: string;
+    timestampGranularities?: "word" | "segment";
+    diarize?: boolean;
+    language?: string;
+    outputPath?: string;
+  }): Promise<FireworksResponse> {
+    const {
+      audioPath,
+      vadModel = "whisperx-pyannet",
+      alignmentModel = "tdnn_ffn",
+      responseFormat = "verbose_json",
+      preprocessing = "none",
+      temperature = "0,0.2,0.4,0.6,0.8,1",
+      timestampGranularities = "word",
+      diarize = false,
+      language,
+      outputPath,
+    } = options;
+
+    if (!process.env.FIREWORKS_API_KEY) {
+      throw new Error("FIREWORKS_API_KEY environment variable is required");
+    }
+
+    console.log("[fireworks] transcribing audio...");
+
+    // Load audio file
+    let audioBlob: Blob;
+    let fileName = "audio.mp3";
+
+    if (audioPath.startsWith("http://") || audioPath.startsWith("https://")) {
+      const audioResponse = await fetch(audioPath);
+      audioBlob = await audioResponse.blob();
+      fileName = audioPath.split("/").pop()?.split("?")[0] || "audio.mp3";
+    } else {
+      const buffer = readFileSync(audioPath);
+      audioBlob = new Blob([buffer]);
+      fileName = audioPath.split("/").pop() || "audio.mp3";
+    }
+
+    // Prepare form data
+    const formData = new FormData();
+    formData.append("file", audioBlob, fileName);
+    formData.append("vad_model", vadModel);
+    formData.append("alignment_model", alignmentModel);
+    formData.append("response_format", responseFormat);
+    formData.append("preprocessing", preprocessing);
+    formData.append("temperature", temperature);
+    formData.append("timestamp_granularities", timestampGranularities);
+    formData.append("diarize", diarize.toString());
+
+    if (language) {
+      formData.append("language", language);
+    }
+
+    // Call Fireworks API
+    const response = await fetch(
+      "https://audio-prod.us-virginia-1.direct.fireworks.ai/v1/audio/transcriptions",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${process.env.FIREWORKS_API_KEY}`,
+        },
+        body: formData,
+      },
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error("[fireworks] api error:", errorText);
+      throw new Error(`fireworks api error: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as FireworksResponse;
+
+    console.log(
+      `[fireworks] transcription complete (${data.words?.length || 0} words)`,
+    );
+
+    // Save to file if requested
+    if (outputPath) {
+      let content: string;
+
+      if (outputPath.endsWith(".srt")) {
+        content = convertToSRT(data.words || []);
+      } else if (outputPath.endsWith(".json")) {
+        content = JSON.stringify(data, null, 2);
+      } else {
+        content = data.text;
+      }
+
+      writeFileSync(outputPath, content);
+      console.log(`[fireworks] saved to ${outputPath}`);
+    }
+
+    return data;
+  }
+}
+
+// Helper function to convert words to SRT format
+function formatTime(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+  const millis = Math.floor((seconds % 1) * 1000);
+
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")},${String(millis).padStart(3, "0")}`;
+}
+
+export function convertToSRT(words: FireworksWord[]): string {
+  let srt = "";
+  let index = 1;
+
+  for (const word of words) {
+    const startTime = formatTime(word.start);
+    const endTime = formatTime(word.end);
+
+    srt += `${index}\n`;
+    srt += `${startTime} --> ${endTime}\n`;
+    srt += `${word.word.trim()}\n\n`;
+    index++;
+  }
+
+  return srt;
+}
+
+// Export singleton instance
+export const fireworksProvider = new FireworksProvider();
+
+// Re-export convenience functions for backward compatibility
+export const transcribeWithFireworks = (
+  options: Parameters<FireworksProvider["transcribe"]>[0],
+) => fireworksProvider.transcribe(options);
+export const convertFireworksToSRT = convertToSRT;

package/src/providers/groq.ts

@@ -0,0 +1,149 @@
+/**
+ * Groq provider for ultra-fast LLM inference
+ * Supports Llama, Mixtral, Gemma models and Whisper transcription
+ */
+
+import Groq from "groq-sdk";
+import type { Uploadable } from "groq-sdk/uploads";
+import type { JobStatusUpdate, ProviderConfig } from "../core/schema/types";
+import { BaseProvider } from "./base";
+
+export class GroqProvider extends BaseProvider {
+  readonly name = "groq";
+  private client: Groq;
+
+  constructor(config?: ProviderConfig) {
+    super(config);
+    this.client = new Groq({
+      apiKey: config?.apiKey || process.env.GROQ_API_KEY || "",
+    });
+  }
+
+  async submit(
+    _model: string,
+    _inputs: Record<string, unknown>,
+    _config?: ProviderConfig,
+  ): Promise<string> {
+    // Groq is synchronous for chat, so we generate a fake job ID
+    const jobId = `groq_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    console.log(`[groq] starting inference: ${jobId}`);
+    return jobId;
+  }
+
+  async getStatus(_jobId: string): Promise<JobStatusUpdate> {
+    return { status: "completed" };
+  }
+
+  async getResult(_jobId: string): Promise<unknown> {
+    return null;
+  }
+
+  // ============================================================================
+  // High-level convenience methods
+  // ============================================================================
+
+  async chatCompletion(options: {
+    model?: string;
+    messages: Array<{
+      role: "system" | "user" | "assistant";
+      content: string;
+    }>;
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+  }) {
+    const {
+      model = GROQ_MODELS.LLAMA_90B,
+      messages,
+      temperature = 1,
+      maxTokens = 1024,
+      stream = false,
+    } = options;
+
+    console.log(`[groq] chat completion with ${model}...`);
+
+    if (stream) {
+      const streamResponse = await this.client.chat.completions.create({
+        model,
+        messages,
+        temperature,
+        max_tokens: maxTokens,
+        stream: true,
+      });
+      console.log(`[groq] streaming response...`);
+      return streamResponse;
+    }
+
+    const response = await this.client.chat.completions.create({
+      model,
+      messages,
+      temperature,
+      max_tokens: maxTokens,
+      stream: false,
+    });
+
+    const content = response.choices[0]?.message?.content || "";
+    console.log(`[groq] completed (${response.usage?.total_tokens} tokens)`);
+    return content;
+  }
+
+  async transcribeAudio(options: {
+    file: Uploadable;
+    model?: string;
+    language?: string;
+    prompt?: string;
+    temperature?: number;
+  }) {
+    const {
+      file,
+      model = GROQ_MODELS.WHISPER_LARGE,
+      language,
+      prompt,
+      temperature,
+    } = options;
+
+    console.log(`[groq] transcribing audio with ${model}...`);
+
+    const response = await this.client.audio.transcriptions.create({
+      file,
+      model,
+      language,
+      prompt,
+      temperature,
+    });
+
+    console.log(`[groq] transcription completed`);
+    return response.text;
+  }
+
+  async listModels() {
+    console.log(`[groq] fetching available models...`);
+    const response = await this.client.models.list();
+    const models = Array.from(response.data);
+    console.log(`[groq] found ${models.length} models`);
+    return models;
+  }
+}
+
+// Popular models
+export const GROQ_MODELS = {
+  LLAMA_90B: "llama-3.3-70b-versatile",
+  LLAMA_8B: "llama-3.1-8b-instant",
+  LLAMA_70B: "llama-3.1-70b-versatile",
+  MIXTRAL_8X7B: "mixtral-8x7b-32768",
+  GEMMA_7B: "gemma-7b-it",
+  GEMMA_2_9B: "gemma2-9b-it",
+  WHISPER_LARGE: "whisper-large-v3",
+};
+
+// Export singleton instance
+export const groqProvider = new GroqProvider();
+
+// Re-export convenience functions for backward compatibility
+export const chatCompletion = (
+  options: Parameters<GroqProvider["chatCompletion"]>[0],
+) => groqProvider.chatCompletion(options);
+export const transcribeAudio = (
+  options: Parameters<GroqProvider["transcribeAudio"]>[0],
+) => groqProvider.transcribeAudio(options);
+export const listModels = () => groqProvider.listModels();

package/src/providers/higgsfield.ts

@@ -0,0 +1,145 @@
+/**
+ * Higgsfield provider for Soul image generation and character creation
+ */
+
+import {
+  BatchSize,
+  HiggsfieldClient,
+  InputImageType,
+  SoulQuality,
+  SoulSize,
+} from "@higgsfield/client";
+import type { JobStatusUpdate, ProviderConfig } from "../core/schema/types";
+import { BaseProvider } from "./base";
+
+export class HiggsfieldProvider extends BaseProvider {
+  readonly name = "higgsfield";
+  private _client: HiggsfieldClient | null = null;
+
+  /**
+   * Lazy initialization of the client to avoid errors when API keys aren't set
+   */
+  private get client(): HiggsfieldClient {
+    if (!this._client) {
+      const apiKey =
+        this.config.apiKey ||
+        process.env.HIGGSFIELD_API_KEY ||
+        process.env.HF_API_KEY;
+      const apiSecret =
+        process.env.HIGGSFIELD_SECRET || process.env.HF_API_SECRET;
+
+      if (!apiKey || !apiSecret) {
+        throw new Error(
+          "Higgsfield API credentials not found. Set HIGGSFIELD_API_KEY/HF_API_KEY and HIGGSFIELD_SECRET/HF_API_SECRET environment variables.",
+        );
+      }
+
+      this._client = new HiggsfieldClient({ apiKey, apiSecret });
+    }
+    return this._client;
+  }
+
+  async submit(
+    model: string,
+    inputs: Record<string, unknown>,
+    _config?: ProviderConfig,
+  ): Promise<string> {
+    const jobSet = await this.client.generate(model as "/v1/text2image/soul", {
+      prompt: inputs.prompt as string,
+      width_and_height:
+        (inputs.widthAndHeight as (typeof SoulSize)[keyof typeof SoulSize]) ||
+        SoulSize.PORTRAIT_1152x2048,
+      quality:
+        (inputs.quality as (typeof SoulQuality)[keyof typeof SoulQuality]) ||
+        SoulQuality.HD,
+      style_id: inputs.styleId as string | undefined,
+      batch_size:
+        (inputs.batchSize as (typeof BatchSize)[keyof typeof BatchSize]) ||
+        BatchSize.SINGLE,
+      enhance_prompt: (inputs.enhancePrompt as boolean) ?? false,
+    });
+
+    console.log(`[higgsfield] job submitted: ${jobSet.id}`);
+    return jobSet.id;
+  }
+
+  async getStatus(_jobId: string): Promise<JobStatusUpdate> {
+    // Higgsfield jobs complete synchronously via submit
+    return { status: "completed" };
+  }
+
+  async getResult(_jobId: string): Promise<unknown> {
+    return null;
+  }
+
+  // ============================================================================
+  // High-level convenience methods
+  // ============================================================================
+
+  async generateSoul(args: {
+    prompt: string;
+    widthAndHeight?: (typeof SoulSize)[keyof typeof SoulSize];
+    quality?: (typeof SoulQuality)[keyof typeof SoulQuality];
+    styleId?: string;
+    batchSize?: (typeof BatchSize)[keyof typeof BatchSize];
+    enhancePrompt?: boolean;
+  }) {
+    console.log("[higgsfield] generating soul image");
+    console.log(`[higgsfield] prompt: ${args.prompt}`);
+
+    const jobSet = await this.client.generate("/v1/text2image/soul", {
+      prompt: args.prompt,
+      width_and_height: args.widthAndHeight || SoulSize.PORTRAIT_1152x2048,
+      quality: args.quality || SoulQuality.HD,
+      style_id: args.styleId,
+      batch_size: args.batchSize || BatchSize.SINGLE,
+      enhance_prompt: args.enhancePrompt ?? false,
+    });
+
+    console.log(`[higgsfield] job created: ${jobSet.id}`);
+    return jobSet;
+  }
+
+  async listSoulStyles() {
+    console.log("[higgsfield] fetching soul styles");
+    return this.client.getSoulStyles();
+  }
+
+  async createSoulId(args: { name: string; imageUrls: string[] }) {
+    console.log(`[higgsfield] creating soul id: ${args.name}`);
+    console.log(`[higgsfield] images: ${args.imageUrls.length}`);
+
+    const soulId = await this.client.createSoulId({
+      name: args.name,
+      input_images: args.imageUrls.map((url) => ({
+        type: InputImageType.IMAGE_URL,
+        image_url: url,
+      })),
+    });
+
+    console.log(`[higgsfield] soul id created: ${soulId.id}`);
+    return soulId;
+  }
+
+  async listSoulIds(page = 1, pageSize = 20) {
+    console.log("[higgsfield] listing soul ids");
+    return this.client.listSoulIds(page, pageSize);
+  }
+}
+
+// Re-export useful enums
+export { BatchSize, SoulQuality, SoulSize };
+
+// Export singleton instance (lazy initialization means no error on import)
+export const higgsfieldProvider = new HiggsfieldProvider();
+
+// Re-export convenience functions for backward compatibility
+export const generateSoul = (
+  args: Parameters<HiggsfieldProvider["generateSoul"]>[0],
+) => higgsfieldProvider.generateSoul(args);
+export const listSoulStyles = () => higgsfieldProvider.listSoulStyles();
+export const createSoulId = (
+  args: Parameters<HiggsfieldProvider["createSoulId"]>[0],
+) => higgsfieldProvider.createSoulId(args);
+export const listSoulIds = (page?: number, pageSize?: number) =>
+  higgsfieldProvider.listSoulIds(page, pageSize);

package/src/providers/index.ts

@@ -0,0 +1,143 @@
+/**
+ * Provider exports
+ * Central registry of all available providers
+ */
+
+export type {
+  ApifyProviderConfig,
+  ApifyRunResult,
+  RunActorOptions,
+} from "./apify";
+// Apify provider (web scraping / actors)
+export {
+  ACTORS,
+  ApifyProvider,
+  apifyProvider,
+  downloadVideos,
+  getDataset,
+  getKeyValueStoreValue,
+  getRunInfo,
+  runActor,
+  waitForRun,
+} from "./apify";
+export type { ProviderResult } from "./base";
+// Base provider infrastructure
+export {
+  BaseProvider,
+  downloadToFile,
+  ensureUrl,
+  getExtension,
+  ProviderRegistry,
+  providers,
+} from "./base";
+// ElevenLabs provider (voice/audio)
+export {
+  ElevenLabsProvider,
+  elevenlabsProvider,
+  generateMusic as generateMusicElevenlabs,
+  generateSoundEffect,
+  getVoice,
+  listVoices,
+  textToSpeech,
+  VOICES,
+} from "./elevenlabs";
+// Fal.ai provider (video/image generation)
+export {
+  FalProvider,
+  falProvider,
+  generateImage,
+  imageToImage,
+  imageToVideo,
+  textToMusic,
+  textToVideo,
+  wan25,
+} from "./fal";
+export type { ProbeResult } from "./ffmpeg";
+// FFmpeg provider (local video editing)
+export {
+  addAudio,
+  concatVideos,
+  convertFormat,
+  extractAudio,
+  FFmpegProvider,
+  fadeVideo,
+  ffmpegProvider,
+  getVideoDuration,
+  probe,
+  resizeVideo,
+  splitAtTimestamps,
+  trimVideo,
+  xfadeVideos,
+} from "./ffmpeg";
+export type { FireworksResponse, FireworksWord } from "./fireworks";
+// Fireworks provider (transcription)
+export {
+  convertFireworksToSRT,
+  FireworksProvider,
+  fireworksProvider,
+  transcribeWithFireworks,
+} from "./fireworks";
+// Groq provider (LLM inference)
+export {
+  chatCompletion,
+  GROQ_MODELS,
+  GroqProvider,
+  groqProvider,
+  listModels,
+  transcribeAudio,
+} from "./groq";
+// Higgsfield provider (Soul image generation)
+export {
+  BatchSize,
+  createSoulId,
+  generateSoul,
+  HiggsfieldProvider,
+  higgsfieldProvider,
+  listSoulIds,
+  listSoulStyles,
+  SoulQuality,
+  SoulSize,
+} from "./higgsfield";
+// Replicate provider (video/image generation)
+export {
+  MODELS,
+  ReplicateProvider,
+  replicateProvider,
+  runImage,
+  runModel,
+  runVideo,
+} from "./replicate";
+export type { StorageConfig } from "./storage";
+// Storage provider (Cloudflare R2 / S3)
+export {
+  generatePresignedUrl,
+  getPublicUrl,
+  StorageProvider,
+  storageProvider,
+  uploadBuffer,
+  uploadFile,
+  uploadFromUrl,
+} from "./storage";
+
+// Register all providers
+import { apifyProvider } from "./apify";
+import { providers } from "./base";
+import { elevenlabsProvider } from "./elevenlabs";
+import { falProvider } from "./fal";
+import { ffmpegProvider } from "./ffmpeg";
+import { fireworksProvider } from "./fireworks";
+import { groqProvider } from "./groq";
+import { higgsfieldProvider } from "./higgsfield";
+import { replicateProvider } from "./replicate";
+import { storageProvider } from "./storage";
+
+// Auto-register all providers
+providers.register(apifyProvider);
+providers.register(falProvider);
+providers.register(replicateProvider);
+providers.register(elevenlabsProvider);
+providers.register(groqProvider);
+providers.register(fireworksProvider);
+providers.register(higgsfieldProvider);
+providers.register(ffmpegProvider);
+providers.register(storageProvider);