@alquimia-ai/tools 1.0.13 → 1.0.16

package/src/sdk/alquimia-sdk.ts

@@ -1,205 +0,0 @@
-import axios, { AxiosInstance } from "axios";
-import {
-  StableDiffusionProvider,
-  WhisperProvider,
-  CharacterizationProvider,
-  RatingsProvider,
-  LoggerProvider,
-} from "../providers";
-interface AlquimiaSDKConfig {
-  apiKey: string;
-  chatUrl: string;
-  streamUrl: string;
-  assistantId: string;
-}
-
-
-class AlquimiaSDK {
-  private config: AlquimiaSDKConfig;
-  private axiosInstance: AxiosInstance;
-  private conversationId: string | null = null;
-  private sessionId: string | null = null;
-  private streamId: string | null = null;
-  private tools: any = {};
-  private extraData: any = {};
-  private forceProfile: any = {};
-  private whisperProvider?: WhisperProvider
-  private stableDiffusionProvider?: StableDiffusionProvider
-  private analyzeCharacterizationProvider?: CharacterizationProvider
-  private ratingsProvider?: RatingsProvider
-  private loggerProvider?: LoggerProvider
-  private enforceCharacterization?: boolean
-  
-  constructor(config: AlquimiaSDKConfig, enforceCharacterization: boolean = true) {
-    this.config = config;
-    this.enforceCharacterization = enforceCharacterization;
-
-    this.axiosInstance = axios.create();
-    this.axiosInstance.interceptors.response.use(
-      (response) => response,
-      async (error) => {
-        if (error.response?.status) {
-          if (this.loggerProvider) {
-            await this.loggerProvider.logError(
-              'Server Error',
-              error,
-              {
-                url: error.config.url,
-                method: error.config.method,
-                data: error.config.data,
-                status: error.response.status,
-                responseData: error.response.data
-              }
-            );
-          }
-        }
-        return Promise.reject(error);
-      }
-    );
-  
-    this.textToSpeech = this.textToSpeech.bind(this);
-    this.speechToText = this.speechToText.bind(this);
-  }
-
-  static configure(
-    apiKey: string,
-    inferUrl: string,
-    streamUrl: string,
-    assistantId: string
-  ): AlquimiaSDKConfig {
-    return {
-      apiKey,
-      chatUrl: `${inferUrl}/chat/${assistantId}`,
-      streamUrl: `${streamUrl}`,
-      assistantId: assistantId
-    };
-  }
-
-  widthConversationId(conversationId: string ): AlquimiaSDK {
-    this.conversationId = conversationId  
-    return this;
-  }
-
-  withWhisperProvider(provider: WhisperProvider): AlquimiaSDK {
-    this.whisperProvider = provider;
-    return this;
-  }
-
-  withStableDiffusionProvider(provider: StableDiffusionProvider): AlquimiaSDK {
-    this.stableDiffusionProvider = provider
-    return this
-  }
-
-  withAnalyzeCharacterizationProvider(provider: CharacterizationProvider): AlquimiaSDK {
-    this.analyzeCharacterizationProvider = provider
-    return this
-  }
-
-  withRatingsProvider(provider: RatingsProvider): AlquimiaSDK {
-    this.ratingsProvider = provider
-    return this
-  }
-
-  withLoggerProvider(provider: LoggerProvider): AlquimiaSDK {
-    this.loggerProvider = provider
-    return this
-  }
-
-  getEnforceCharacterization(): boolean {
-    return this.enforceCharacterization ?? true;
-  }
-
-  withTools(tools: any): AlquimiaSDK {
-    this.tools = tools;
-    return this;
-  }
-
-  withExtraData(extraData: any): AlquimiaSDK {
-    this.extraData = extraData;
-    return this;
-  }
-
-  withForceProfile(forceProfile: any): AlquimiaSDK {
-    this.forceProfile = forceProfile;
-    return this;
-  }
-
-  textToSpeech(text: string): Promise<Blob> {
-    if (!this.whisperProvider) {
-      throw new Error("Whisper provider not initialized");
-    }
-    return this.whisperProvider.textToSpeech(text)
-  }
-
-  speechToText(audio: string): Promise<string> {
-    if (!this.whisperProvider) {
-      throw new Error("Whisper provider not initialized");
-    }
-    return this.whisperProvider.speechToText(audio)
-  }
-
-  async sendMessage(query: string, traceParent?: string) {
-    if (!this.conversationId) {
-      throw new Error("Conversation not initialized");
-    }
-
-    const initMessage = {
-        query,
-        session_id: this.conversationId,
-        tools: this.tools,
-        extra_data: this.extraData,
-        force_profile: this.forceProfile
-      };
- 
-      const result = (await this.axiosInstance.post(this.config.chatUrl, initMessage, {
-        headers: {
-          "Content-Type": "application/json",
-          "x-trace-parent": traceParent || "",
-        },
-      })).data
-    
-      this.streamId = result.data.stream_id;
-      return this
-  }
-
-  async generateImage(query: string) {
-    if (!this.stableDiffusionProvider) {
-      throw new Error("Stable Diffusion provider not initialized");
-    }
-    return this.stableDiffusionProvider.generateImage(query)
-  }
-
-  async analyzeCharacterization(text: string) {
-    if (!this.analyzeCharacterizationProvider) {
-      throw new Error("analyze characterization provider not initialized");
-    }
-    return this.analyzeCharacterizationProvider.analyzeCharacterization(text)
-  }
-
-  async rate(data: any) {
-    if (!this.ratingsProvider) {
-      throw new Error("ratings provider not initialized");
-    }
-    return this.ratingsProvider.rate(data)
-  }
-
-  async logInfo(message: string, data: any) {
-    if (!this.loggerProvider) {
-      throw new Error("logger provider not initialized");
-    }
-    return this.loggerProvider.logInfo(message, data)
-  }
-
-  async logError(message: string, error: Error, data: any) {
-    if (!this.loggerProvider) {
-      throw new Error("logger provider not initialized");
-    }
-    return this.loggerProvider.logError(message, error, data)
-  }
-
-  getUrlStream() {
-    return `${this.config.streamUrl}/${this.streamId}`;
-  }
-}
-
-export default AlquimiaSDK;

package/src/sdk/index.ts

@@ -1 +0,0 @@
-export { default as AlquimiaSDK } from './alquimia-sdk';

package/src/services/apm/elastic-apm.ts

@@ -1,103 +0,0 @@
-'use client'
-
-import { useEffect } from 'react'
-import { init as initApm, apm, Transaction } from '@elastic/apm-rum'
-import { ApmSpan } from '../../types/type'
-
-interface APMInitializerProps {
-  serviceName: string
-  serverUrl?: string
-  serverUrlPrefix?: string | undefined
-  logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error'
-  environment: string
-  ignoreUrls?: Array<string | RegExp>
-}
-
-type LabelValue = string | number | boolean | null;
-
-interface TransactionLabels {
-  [key: string]: LabelValue;
-}
-
-export function APMInitializer({
-  serviceName,
-  serverUrl,
-  serverUrlPrefix = undefined,
-  logLevel = 'warn',
-  environment,
-  ignoreUrls = []
-}: APMInitializerProps) {
-  
-  useEffect(() => {
-    const serviceUrl = !serverUrl ? (typeof window !== 'undefined' ? window.location.origin : '') : serverUrl
-    initApm({
-      serviceName: serviceName,
-      serverUrl: serviceUrl,
-      serverUrlPrefix: serverUrlPrefix,
-      serviceVersion: '1.0.0',
-      logLevel: logLevel,
-      environment: environment,
-      ignoreTransactions: ignoreUrls
-    })
-  }, [])
-  
-  return null
-}
-
-
-export async function handleApmTransaction(
-  name: string,
-  type: string,
-  labels: TransactionLabels,
-  callback: () => Promise<void> | void
-) {
-  const transaction = apm.startTransaction(name, type);
-
-  try {
-    transaction?.addLabels(labels as Labels);
-    await callback();
-  } catch (error) {
-    apm.captureError(error as Error);
-  } finally {
-    transaction?.end();
-  }
-}
-
-export function traceError(
-  error: string | Error,
-  labels?: TransactionLabels,
-  customMessage?: string
-) {
-  try {
-    const errorObject =
-      error instanceof Error
-        ? error
-        : new Error(customMessage ?? String(error));
-
-    if (labels) {
-      apm.addLabels(labels as Labels);
-    }
-
-    apm.captureError(errorObject);
-  } catch (e) {
-    throw new Error("Failed to capture error in APM:", e as Error);
-  }
-}
-
-export const startManagedTransaction = (
-  name: string,
-  type: string = 'http-request',
-  spanName: string,
-  spanType: string = 'external.http'
-): { transaction: Transaction | undefined, span: ApmSpan | undefined, traceParentId: string | undefined } => {
-  const transaction = apm.startTransaction(name, type, { managed: true });
-  const span: ApmSpan | undefined = transaction?.startSpan(spanName, spanType);
-  
-  const traceParentId = span ? createTraceParentId(span.traceId || '', span.id || '') : undefined;
-  
-  return { transaction, span, traceParentId };
-};
-
-const createTraceParentId = (traceId: string, spanId: string) => {
-  return `00-${traceId}-${spanId}-01`;
-}

package/src/services/apm/index.ts

@@ -1 +0,0 @@
-export * from "./elastic-apm";

package/src/services/index.ts

@@ -1 +0,0 @@
-export * from './apm'

package/src/types/index.ts

@@ -1 +0,0 @@
-export * from './type'

package/src/types/type.ts

@@ -1,127 +0,0 @@
-import { Span } from "@elastic/apm-rum";
-import { Message } from "ai";
-export interface ITooler {
-  tooler: Array<{
-    name: string;
-    parameters: Record<string, any>;
-  }>;
-}
-
-export interface IToolSpec {
-  name: string;
-  parameters: Record<string, any>;
-}
-
-export abstract class ToolFactory {
-  protected toolSpec: IToolSpec | null = null;
-
-  constructor(toolSpec: IToolSpec) {
-    this.toolSpec = toolSpec;
-  }
-
-  static createTool(toolSpec: IToolSpec): IToolSpec {
-    return toolSpec;
-  }
-
-  abstract execute(): Promise<any>;
-}
-
-export interface AIMessageChunk {
-  type: string;
-  data?: AIMessageChunkData;
-  error_code?: string;
-  error_detail?: string;
-  loading?: boolean;
-}
-
-export interface AIMessageChunkData {
-  content: string;
-  additional_kwargs?: Record<string, unknown>;
-  response_metadata?: Record<string, unknown>;
-  type: string;
-  name?: string | null;
-  id?: string | null;
-  example?: boolean;
-  tool_calls?: ToolCall[];
-  invalid_tool_calls?: InvalidToolCall[];
-  usage_metadata?: any;
-  tool_call_chunks?: unknown[];
-  error_code?: string;
-  error_detail?: string;
-}
-
-type ToolCall = {
-  name: string;
-  args: Record<string, any>;
-  id?: string | null;
-};
-
-type InvalidToolCall = {
-  name: string | null;
-  args: string | null;
-  id: string | null;
-  error: string | null;
-};
-
-export interface BaseAPIConfig {
-  baseUrl: string;
-  route: string;
-  token?: string;
-  headers?: Record<string, string>;
-}
-
-export interface RatingData {
-  assistantId: string;
-  sessionId: string;
-  topicId: number;
-  score?: number;
-  description?: string;
-}
-
-export type AlquimiaMessage = Message & {
-  error_code?: string;
-  error_detail?: string;
-  loading?: boolean;
-  created_at?: string;
-  additionalInfo?: string;
-};
-
-export interface ActionResponse<T = void> {
-  success: boolean;
-  data?: T;
-  error?: {
-    message: string;
-    code?: string;
-    details?: any;
-    name?: string;
-    cause?: string;
-    status?: string;
-  };
-}
-
-export type ApmSpan = Span & {
-  id?: string 
-  traceId?: string
-} | undefined
-
-export type ApiError = Error & {
-  message: string;
-  name: string;
-  cause: string;
-  code?: string | number;
-  status?: string | number;
-}
-
-export interface ConversationsMap {
-  [topicId: string]: string;
-}
-
-export interface DocumentSearchResult {
-  pageContent: string;
-  metadata: {
-    source: string;
-    _id: string;
-    _collection_name: string;
-  };
-  score: number;
-}

package/src/utils/index.ts

@@ -1 +0,0 @@
-export * from './utils';

package/src/utils/utils.ts

@@ -1,137 +0,0 @@
-import { BaseAPIConfig, ApiError, ConversationsMap } from "../types/type";
-
-export function generateTranslatePrompt(text: string) {
-  const prompt = `
-        Arrange the following text according to the given object structure and return it as plain json, values summarized to one word, no formatting:
-        {
-            restrictions: {
-                value: [''],
-                description: 'Restrictions to certain foods'
-            },
-            alergies: {
-                value: [''],
-                description: 'Alergies to certain foods'
-            },
-            wine_preference: {
-                value: [''],
-                description: 'Preferences for the wine'
-            },
-            meal_preference: {
-                value: [''],
-                description: 'Preferences for the meal'
-            }
-        }
-
-        Text: "${text}"
-
-        Output:
-    `;
-
-  return prompt;
-}
-
-export function getCookies(name: string) {
-  if (typeof document === 'undefined') return undefined;
-  const value = `; ${document.cookie}`;
-  const parts = value.split(`; ${name}=`);
-  if (parts.length === 2) return parts.pop()?.split(";").shift();
-}
-
-export function generateHeaders(config: BaseAPIConfig): HeadersInit {
-  const headers: HeadersInit = {
-    "Content-Type": "application/json",
-  };
-
-  if (config.token) {
-    headers["Authorization"] = `Bearer ${config.token}`;
-  }
-
-  if (config.headers) {
-    Object.entries(config.headers).forEach(([key, value]) => {
-      headers[key] = value;
-    });
-  }
-
-  return headers;
-}
-
-export function isTextContent(buffer: ArrayBuffer): boolean {
-  try {
-    const text = new TextDecoder().decode(buffer);
-    return /^[\w\#\-\*]/.test(text.trim());
-  } catch {
-    return false;
-  }
-}
-
-export function getQueryParam(param: string): string | null {
-  if (typeof window !== 'undefined') {
-    const urlParams = new URLSearchParams(window.location.search);
-    return urlParams.get(param);
-  }
-  return null;
-}
-
-export function defineAssistantId(defaultId: string): string {
-  if (typeof window !== 'undefined' && window.location.pathname === '/') {
-    const queryAssistantId = getQueryParam('talkwith');
-    if (queryAssistantId) {
-      localStorage.setItem('assistantId', queryAssistantId);
-      return queryAssistantId;
-    }
-    const storedAssistantId = localStorage.getItem('assistantId');
-    return storedAssistantId || defaultId;
-  }
-  return defaultId;
-}
-
-export function formatTimeWithUnit(timeMs: number): string {
-  if (timeMs >= 1000) {
-    return `${(timeMs / 1000).toFixed(1)}s`;
-  }
-  return `${Math.round(timeMs)}ms`;
-};
-
-export function serializeAxiosError(error: unknown){
-  if (error instanceof Error) {
-    const customError = error as ApiError;
-    return {
-      message: customError?.message, 
-      name: customError?.name,
-      stack: customError?.stack,
-      code: customError?.code,
-      status: customError?.status,
-    };
-  }
-  return {
-    message: String(error),
-    name: 'Unknown Error',
-  };
-};
-
-export function parseConversationsMapCookie(cookieValue: string): ConversationsMap {
-  try {
-    const decodedValue = decodeURIComponent(cookieValue);
-    return JSON.parse(decodedValue) as ConversationsMap;
-  } catch (e) {
-    console.error('Error parsing conversations cookie:', e);
-    return {};
-  }
-}
-
-export function getTopicSessionId(topicId: string): string {
-  const conversationsStr = getCookies("alquimia-sessions") || "{}";
-  if (!conversationsStr) {
-    const sessionCookie = getCookies("alquimia-session");
-    return sessionCookie || "";
-  }
-
-  const conversationsMap = parseConversationsMapCookie(conversationsStr);
-  return conversationsMap[topicId] || "";
-}
-
-export function createMessageId() {
-  return Math.floor(Math.random() * 1000000).toString();
-}
-
-