@alquimia-ai/tools 1.0.13 → 1.0.16

package/src/hooks/useRatings.ts

@@ -1,107 +0,0 @@
-
-import { useState, useReducer } from "react";
-import { RatingData } from "../types/type";
-import { getTopicSessionId } from "../utils/utils";
-
-interface RatingState {
-  ratingStars: number;
-  ratingThumbs: "thumbsUp" | "thumbsDown" | "";
-  ratingComment: string;
-}
-
-type RatingAction =
-  | { type: "SET_RATING_STARS"; payload: number }
-  | { type: "SET_RATING_THUMBS"; payload: "thumbsUp" | "thumbsDown" | "" }
-  | { type: "SET_RATING_COMMENT"; payload: string };
-
-const initialState: RatingState = {
-  ratingStars: 0,
-  ratingThumbs: "",
-  ratingComment: "",
-};
-
-function ratingReducer(state: RatingState, action: RatingAction): RatingState {
-  switch (action.type) {
-    case "SET_RATING_STARS":
-      return { ...state, ratingStars: action.payload };
-    case "SET_RATING_THUMBS":
-      return { ...state, ratingThumbs: action.payload };
-    case "SET_RATING_COMMENT":
-      return { ...state, ratingComment: action.payload };
-    default:
-      return state;
-  }
-}
-
-interface UseRatingsParams {
-    assistantId: string;
-    topicId: string;
-    sendRating: (ratingData: RatingData) => Promise<any>;
-    onError?: (componentName: string, error: Error) => void;
-}
-
-
-export function useRatings({ assistantId, sendRating, topicId }: UseRatingsParams) {
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [hasReviewed, setHasReviewed] = useState<boolean>(false);
-  const [state, dispatch] = useReducer(ratingReducer, initialState);
-
-  const setRatingStars = (rating: number) => {
-    dispatch({ type: "SET_RATING_STARS", payload: rating });
-  };
-
-  const setRatingThumbs = (rating: "thumbsUp" | "thumbsDown" | "") => {
-    dispatch({ type: "SET_RATING_THUMBS", payload: rating });
-  };
-
-  const setRatingComment = (comment: string) => {
-    dispatch({ type: "SET_RATING_COMMENT", payload: comment });
-  };
-
-  const thumbsScore = (value: string) => {
-    return value === "thumbsUp" ? 5 : value === "thumbsDown" ? 0 : 0;
-  }
-
-  const handleRate = async (key: string, value: any | string, onHandleRateSuccess: (success: boolean, err?: string) => void) => {
-    setIsLoading(true);
-    const sessionId = getTopicSessionId(topicId);
-
-    const ratingObj: RatingData = {
-      topicId: parseInt(topicId),
-      sessionId:  sessionId || "",
-      assistantId: assistantId,
-      score: key === "score" ? value : thumbsScore(value),
-      description: key === "description" ? value : state.ratingComment,
-    };
-
-    try {
-      const response = await sendRating(ratingObj);
-      if (!response.success) {
-        setIsLoading(false);
-        onHandleRateSuccess(false, response.error.message);
-        return;
-      }
-  
-      if (key === "score") {
-        setRatingStars(value);
-      } else if (key === "description") {
-        setRatingComment(value);
-      }
-      setHasReviewed(true);
-      setIsLoading(false);
-      onHandleRateSuccess(true);
-    } catch (err) {
-      setIsLoading(false);
-      onHandleRateSuccess(false, String(err));
-    }
-  };
-
-  return {
-    handleRate,
-    ratingStars: state.ratingStars,
-    ratingThumbs: state.ratingThumbs,
-    ratingComment: state.ratingComment,
-    isLoading,
-    hasReviewed
-  };
-}

package/src/providers/alquimia.ts

@@ -1,97 +0,0 @@
-import { WhisperProvider, RatingsProvider } from "./providers";
-import { RatingData } from "../types/type";
-import axios from "axios";
-
-class AlquimiaWhisperProvider extends WhisperProvider {
-  constructor(config: { baseURL: string; ttsRoute: string; sttRoute: string }) {
-    super(config);
-  }
-
-  async textToSpeech(text: string): Promise<any> {
-    const axiosClient = axios.create({
-      baseURL: this.config.baseURL,
-    });
-
-    try {
-      const response = await axiosClient.post(
-        this.config.ttsRoute,
-        {
-          text: text,
-        },
-        { responseType: "blob" }
-      );
-
-      return response.data;
-    } catch (error) {
-      console.error("Error converting text to speech:", error);
-      throw error;
-    }
-  }
-
-  async speechToText(audio: string): Promise<string> {
-    const axiosClient = axios.create({
-      baseURL: this.config.baseURL,
-    });
-
-    try {
-      const response = await axiosClient.post(this.config.sttRoute, {
-        audio: audio,
-      });
-
-      return response.data;
-    } catch (error) {
-      console.error("Error converting speech to text:", error);
-      throw error;
-    }
-  }
-}
-
-class AlquimiaRatingsProvider extends RatingsProvider {
-  constructor(config: { baseUrl: string; route: string; token: string; headers?: Record<string, string> }) {
-    super(config);
-  }
-
-  async rate(data: RatingData): Promise<Record<string, any>> {
-    const path = `${this.config.baseUrl}${this.config.route}`;
-    try {
-      let response;
-      const headers = {
-        Authorization: `Bearer ${this.config.token}`,
-        "Content-Type": "application/json",
-      ...this.config.headers || {}
-      };
-
-      response = await axios.post(`${path}`, data, { headers });
-      return {
-        success: true,
-        data: response.data
-      }
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        return {
-          success: false,
-          error: {
-            message: error.message,
-            response: {
-              status: error.response?.status,
-              data: error.response?.data
-            },
-            details: error.response?.data
-          }
-        };
-      }
-
-      return {
-        success: false,
-        error: {
-          message: error instanceof Error ? error.message : 'Unknown error occurred',
-          response: {
-            status: 500
-          }
-        }
-      };
-    }
-  }
-}
-
-export { AlquimiaWhisperProvider, AlquimiaRatingsProvider };

package/src/providers/elastic-search.ts

@@ -1,82 +0,0 @@
-import { LoggerProvider } from "./providers";
-import pino from "pino";
-
-interface ElasticLoggerConfig {
-  endpoint: string;
-  username: string;
-  password: string;
-  index?: string;
-  esVersion?: number;
-  flushBytes?: number;
-}
-
-class ElasticLoggerProvider extends LoggerProvider {
-  private logger: pino.Logger;
-
-  private constructor(config: ElasticLoggerConfig) {
-    super(config);
-    this.logger = console as any;
-  }
-
-  public static async create(config: ElasticLoggerConfig): Promise<ElasticLoggerProvider> {
-    const provider = new ElasticLoggerProvider(config);
-    await provider.initialize(config);
-    return provider;
-  }
-
-  private async initialize(config: ElasticLoggerConfig) {
-    if (typeof window === 'undefined') {
-      const [pinoElastic] = await Promise.all([
-        import('pino-elasticsearch')
-      ]);
-
-      const streamToElastic = pinoElastic.default({
-        index: config.index || "logs-index",
-        node: config.endpoint,
-        esVersion: config.esVersion || 7,
-        flushBytes: config.flushBytes || 1000,
-        auth: {
-          username: config.username || "",
-          password: config.password || "",
-        },
-        tls: {
-          rejectUnauthorized: false,
-        },
-        op_type: 'create',
-      });
-
-      streamToElastic.on('error', (err) => {
-        console.error('Elasticsearch stream error:', err);
-      });
-
-      streamToElastic.on('insertError', (err) => {
-        console.error('Elasticsearch insert error:', err);
-      });
-
-      streamToElastic.on('insert', () => {
-        console.log('Successfully sent log to Elasticsearch');
-      });
-
-
-      this.logger = pino({
-        level: 'info',
-        timestamp: () => `,"time":"${new Date().toISOString()}"`,
-      }, streamToElastic);
-    }
-  }
-
-  logInfo(message: string, data?: Record<string, any>): void {
-    this.logger.info({ ...data }, message);
-  }
-
-  logError(message: string, error: Error, data?: Record<string, any>): void {
-    const errorDetails = {
-      message: error.message,
-      name: error.name,
-      stack: error.stack,
-    };
-    this.logger.error({ error, ...data, ...errorDetails }, message);
-  }
-}
-
-export { ElasticLoggerProvider };

package/src/providers/eleven-labs.ts

@@ -1,58 +0,0 @@
-import { WhisperProvider } from "./providers";
-import { ElevenLabsClient, ElevenLabs } from "elevenlabs";
-import axios from "axios";
-
-const requestSpecs = {
-  optimize_streaming_latency: ElevenLabs.OptimizeStreamingLatency.Zero,
-  output_format: ElevenLabs.OutputFormat.Mp344100128,
-  model_id: "eleven_multilingual_v1",
-  language: "es",
-  voice_settings: {
-    stability: 0.1,
-    similarity_boost: 0.15,
-    style: 0.2,
-  },
-}; 
-
-class ElevenLabsWhisperProvider extends WhisperProvider {
-    private client: ElevenLabsClient;
-
-    constructor(config: { apiKey: string, voiceId: string, baseURL: string }) {
-        super(config);
-        this.client = new ElevenLabsClient(config);
-    }
-
-    async speechToText(audio: string): Promise<string> {
-      return '';
-    }
-
-    async textToSpeech(text: string): Promise<any> {
-
-        const axiosClient = axios.create({
-            baseURL: this.config.baseURL,
-            headers: {
-              Accept: "audio/mpeg",
-              "Content-Type": "application/json",
-              "Xi-Api-Key": this.config.apiKey,
-            },
-          });
-
-        try {
-            const response = await axiosClient.post(
-              `/v1/text-to-speech/${this.config.voiceId}`,
-              {
-                text: text,
-                ...requestSpecs,
-              },
-              { responseType: 'blob' }
-            );
-
-            return response.data;
-        } catch (error) {
-            console.error('Error converting text to speech:', error);
-            throw error;
-        }
-    }
-}
-
-export { ElevenLabsWhisperProvider };

package/src/providers/index.ts

@@ -1,7 +0,0 @@
-export * from "./providers";
-export * from "./alquimia";
-export * from "./providers";
-export * from "./openai";
-export * from "./stability";
-export * from "./eleven-labs";
-export * from "./elastic-search";

package/src/providers/openai.ts

@@ -1,69 +0,0 @@
-import { generateTranslatePrompt } from "../utils/utils";
-import { StableDiffusionProvider, WhisperProvider, CharacterizationProvider } from "./providers";
-import OpenAI from "openai";
-
-class OpenAIWhisperProvider extends WhisperProvider {
-  async textToSpeech(text: string): Promise<Blob> {
-    return new Blob();
-  }
-
-  async speechToText(audio: string): Promise<string> {
-    return '';
-  }
-}
-class OpenAIAnalyzeCharProvider extends CharacterizationProvider  {
-  private client : any 
-    
-  constructor(config:Record<string,any>){
-      super(config)
-      this.client = new OpenAI({
-          apiKey: config.apiKey
-      })
-  }
-
-  async analyzeCharacterization(text: string): Promise<Record<string, any>>  {
-    const prompt = generateTranslatePrompt(text);
-
-    const response = await this.client.chat.completions.create({
-      model: 'gpt-4o-mini',
-      messages: [
-        { role: 'system', content: 'You are a helpful assistant.' },
-        { role: 'user', content: prompt },
-      ],
-      max_tokens: 150,
-      temperature: 0.7,
-    });
-
-    const arrangedText = response.choices[0].message.content.trim();
-
-    try {
-      const arrangedObject = JSON.parse(arrangedText);
-      return arrangedObject;
-    } catch (error) {
-      throw new Error('Failed to parse the response from OpenAI');
-    }
-  }
-}
-
-class OpenAIStableDiffusionProvider extends StableDiffusionProvider {
-    private client : any 
-    
-    constructor(config:Record<string,any>){
-        super(config)
-        this.client = new OpenAI({
-            apiKey: config.apiKey
-        })
-    }
-
-  async generateImage(query: string): Promise<string> {
-    const response = await this.client.images.generate({
-      model: "dall-e-3",
-      prompt: query,
-      n: 1,
-      size: "1024x1024",
-    });
-    return response.data[0].url;
-  }
-}
-
-export { OpenAIWhisperProvider, OpenAIStableDiffusionProvider, OpenAIAnalyzeCharProvider };

package/src/providers/providers.ts

@@ -1,61 +0,0 @@
-
-export abstract class GenerativeProvider {
-    private config: Record<string, any>;
-
-    constructor(config: Record<string, any>) {
-        this.config = config;
-    }
-}
-
-export abstract class WhisperProvider {
-    protected config: Record<string, any>;
-
-    constructor(config: Record<string, any>) {
-        this.config = config;
-    }
-
-    abstract textToSpeech(text: string): Promise<Blob>
-
-    abstract speechToText(audio: string): Promise<string>
-} 
-
-export abstract class StableDiffusionProvider {
-    protected config: Record<string, any>;
-
-    constructor(config: Record<string, any>) {
-        this.config = config;
-    }
-
-    abstract generateImage(query: string): Promise<string>
-}
-
-export abstract class CharacterizationProvider {
-    protected config: Record<string, any>;
-
-    constructor(config: Record<string, any>) {
-        this.config = config;
-    }
-
-    abstract analyzeCharacterization(text: string): Promise<Record<string, any>>
-}
-
-export abstract class RatingsProvider {
-    protected config: Record<string, any>;
-
-    constructor(config: Record<string, any>) {
-        this.config = config;
-    }
-
-    abstract rate(data: Record<string, any>): Promise<Record<string, any>>;
-}
-
-export abstract class LoggerProvider {
-    protected config: Record<string, any>;
-
-    constructor(config: Record<string, any>) {
-        this.config = config;
-    }
-
-    abstract logInfo(message: string, data?: Record<string, any>): void;
-    abstract logError(message: string, error: Error, data?: Record<string, any>): void;
-}

package/src/providers/stability.ts

@@ -1,38 +0,0 @@
-import { StableDiffusionProvider } from "./providers";
-import { Buffer } from "buffer/";
-import axios from "axios";
-
-class StabilityProvider extends StableDiffusionProvider {
-  constructor(config: Record<string, any>) {
-    super(config);
-  }
-
-  async generateImage(query: string): Promise<string> {
-    const payload = {
-      prompt: "query",
-      output_format: "webp",
-    };
-
-    const response = await axios.postForm(
-      `https://api.stability.ai/v2beta/stable-image/generate/ultra`,
-      axios.toFormData(payload, new FormData()),
-      {
-        validateStatus: undefined,
-        responseType: "arraybuffer",
-        headers: {
-          Authorization: `Bearer ${this.config.apiKey}`,
-          Accept: "image/*",
-        },
-      }
-    );
-
-    if (response.status === 200) {
-      const base64Image = Buffer.from(response.data).toString("base64");
-      return `data:image/webp;base64,${base64Image}`;
-    } else {
-      throw new Error(`${response.status}: ${response.data.toString()}`);
-    }
-  }
-}
-
-export { StabilityProvider };

package/src/reducer/characterization-reducer.tsx

@@ -1,33 +0,0 @@
-export interface CharacterizationState {
-  sessionId: string | null;
-  characterizationData: any;
-}
-
-export type CharacterizationAction =
-  | {
-      type: "SET_SESSION";
-      payload: { sessionId: string; characterizationData: any };
-    }
-  | { type: "CLEAR_SESSION" };
-
-export const characterizationReducer = (
-  state: CharacterizationState,
-  action: CharacterizationAction
-): CharacterizationState => {
-  switch (action.type) {
-    case "SET_SESSION":
-      return {
-        ...state,
-        sessionId: action.payload.sessionId,
-        characterizationData: action.payload.characterizationData,
-      };
-    case "CLEAR_SESSION":
-      return {
-        ...state,
-        sessionId: null,
-        characterizationData: null,
-      };
-    default:
-      return state;
-  }
-};