@alquimia-ai/tools 1.0.13 → 1.0.16

package/src/actions/baseApi.action.ts

@@ -1,187 +0,0 @@
-"use server";
-import { BaseAPIConfig } from "../types/type";
-import { generateHeaders, isTextContent } from "../utils";
-
-interface ActionResponse<T = void> {
-  success: boolean;
-  data?: T;
-  contentType?: string;
-  error?: {
-    message: string;
-    code?: string;
-    details?: any;
-  };
-}
-
-export async function createResource<TResponse, TPayload>(
-  config: BaseAPIConfig,
-  payload: TPayload
-): Promise<ActionResponse<TResponse>> {
-  try {
-    const headers = generateHeaders(config);
-
-    const response = await fetch(`${config.baseUrl}${config.route}`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload),
-      cache: "default",
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      return {
-        success: false,
-        error: {
-          message: error.message || `Server returned ${response.status}`,
-          code: response.status.toString(),
-          details: {
-            status: response.status,
-            statusText: response.statusText,
-          },
-        },
-      };
-    }
-  
-    return {
-      success: true,
-      data: await response.json(),
-    };
-  } catch (error) {
-    throw new Error("Failed to create resource");
-  }
-}
-
-export async function readResource<T>(
-  config: BaseAPIConfig,
-  id?: string
-): Promise<ActionResponse<T>> {
-  try {
-    const headers = generateHeaders(config);
-    const url = id
-      ? `${config.baseUrl}${config.route}/${id}`
-      : `${config.baseUrl}${config.route}`;
-
-    const response = await fetch(url, {
-      method: "GET",
-      headers,
-      cache: "default",
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      return {
-        success: false,
-        error: {
-          message: error.message || `Server returned ${response.status}`,
-          code: response.status.toString(),
-          details: {
-            status: response.status,
-            statusText: response.statusText,
-          },
-        },
-      };
-    }
-
-    const contentType = response.headers.get("content-type");
-    if (contentType?.includes("application/json")) {
-      return {
-        success: true,
-        data: await response.json(),
-        contentType: contentType || undefined,
-      };
-    }
-
-    const arrayBuffer = await response.arrayBuffer();
-
-    if (contentType?.includes("octet-stream") && isTextContent(arrayBuffer)) {
-      return {
-        success: true,
-        data: arrayBuffer as T,
-        contentType: "text/plain",
-      };
-    }
-
-    return {
-      success: true,
-      data: await response.json(),
-      contentType: contentType || undefined,
-    };
-  } catch (error) {
-    throw new Error("Failed to read resource");
-  }
-}
-
-export async function updateResource<T>(
-  config: BaseAPIConfig,
-  id: string,
-  data: T
-): Promise<ActionResponse<T>> {
-  try {
-    const headers = generateHeaders(config);
-
-    const response = await fetch(`${config.baseUrl}${config.route}/${id}`, {
-      method: "PUT",
-      headers,
-      body: JSON.stringify(data),
-      cache: "default",
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      return {
-        success: false,
-        error: {
-          message: error.message || `Server returned ${response.status}`,
-          code: response.status.toString(),
-          details: {
-            status: response.status,
-            statusText: response.statusText,
-          },
-        },
-      };
-    }
-
-    return {
-      success: true,
-      data: await response.json(),
-    };
-  } catch (error) {
-    throw new Error("Failed to update resource");
-  }
-}
-
-export async function deleteResource(
-  config: BaseAPIConfig,
-  id: string
-): Promise<ActionResponse<void>> {
-  try {
-    const headers = generateHeaders(config);
-
-    const response = await fetch(`${config.baseUrl}${config.route}/${id}`, {
-      method: "DELETE",
-      headers,
-      cache: "default",
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      return {
-        success: false,
-        error: {
-          message: error.message || `Server returned ${response.status}`,
-          code: response.status.toString(),
-          details: {
-            status: response.status,
-            statusText: response.statusText,
-          },
-        },
-      };
-    }
-
-    return {
-      success: true,
-    };
-  } catch (error) {
-    throw new Error("Failed to delete resource");
-  }
-}

package/src/actions/chat.action.ts

@@ -1,134 +0,0 @@
-"use server";
-import { NextResponse } from "next/server";
-import { headers } from "next/headers";
-
-export type ChatRouteContext = {
-  params: {
-    path: string[];
-  };
-};
-
-export type ChatRequestConfig = {
-  assistantBaseUrl: string;
-  assistantRoute?: string;
-  apiKey: string;
-};
-
-export type ChatResponse = Response | any;
-
-export async function handleChatRequest(
-  request: Request,
-  context: ChatRouteContext,
-  config: ChatRequestConfig
-): Promise<ChatResponse> {
-  try {
-    const headersList = await headers();
-    const body = await request.json();
-    const routeParams = await context.params;
-    const routePath = routeParams.path.join("/");
-    const assistantRoute = config.assistantRoute || "infer";
-
-    const assistantUrl = `${config.assistantBaseUrl}/${assistantRoute}/${routePath}`;
-
-    const response = await fetch(assistantUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${config.apiKey}`,
-        ...headersList,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const errorJson = await response.json();
-      console.error("Chat inference server error:", {
-        status: response.status,
-        statusText: response.statusText,
-        body: errorJson,
-      });
-
-      return NextResponse.json(
-        {
-          error:
-            errorJson.message ||
-            response.statusText ||
-            "Failed to forward Chat data",
-        },
-        { status: response.status }
-      );
-    }
-
-    return new NextResponse(response.body, {
-      status: 200,
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "POST, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type, Content-Encoding",
-      },
-    });
-  } catch (error) {
-    return NextResponse.json(
-      { error: "Failed to forward Chat data" },
-      { status: 500 }
-    );
-  }
-}
-
-export async function handleStreamRequest(
-  request: Request,
-  context: ChatRouteContext,
-  config: ChatRequestConfig
-): Promise<Response> {
-  try {
-    const headersList = await headers();
-    const routeParams = context.params;
-    const path = routeParams.path.join("/");
-    const assistantRoute = config.assistantRoute || "stream";
-
-    const streamUrl = `${config.assistantBaseUrl}/${assistantRoute}/${path}`;
-
-    const response = await fetch(streamUrl, {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${config.apiKey}`,
-        ...Object.fromEntries(headersList.entries()),
-      },
-    });
-
-    if (!response.ok) {
-      const errorJson = await response.json();
-      console.error("Stream server error:", {
-        status: response.status,
-        statusText: response.statusText,
-        body: errorJson,
-      });
-
-      return new Response(
-        JSON.stringify({
-          error:
-            errorJson.message ||
-            response.statusText ||
-            "Failed to forward Stream data",
-        }),
-        { status: response.status }
-      );
-    }
-
-    return new Response(response.body, {
-      status: 200,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-      },
-    });
-  } catch (error) {
-    console.error("Stream error:", error);
-    return new Response(
-      JSON.stringify({ error: "Failed to forward stream data" }),
-      { status: 500 }
-    );
-  }
-}
-

package/src/actions/index.ts

@@ -1,4 +0,0 @@
-export * from './alquimia.action'
-export * from './baseApi.action'
-export * from './chat.action'
-export * from './apm.action'

package/src/button.tsx

@@ -1,20 +0,0 @@
-"use client";
-
-import { ReactNode } from "react";
-
-interface ButtonProps {
-  children: ReactNode;
-  className?: string;
-  appName: string;
-}
-
-export const Button = ({ children, className, appName }: ButtonProps) => {
-  return (
-    <button
-      className={className}
-      onClick={() => alert(`Hello from your ${appName} app!`)}
-    >
-      {children}
-    </button>
-  );
-};

package/src/card.tsx

@@ -1,25 +0,0 @@
-export function Card({
-  className,
-  title,
-  children,
-  href,
-}: {
-  className?: string;
-  title: string;
-  children: React.ReactNode;
-  href: string;
-}): JSX.Element {
-  return (
-    <a
-      className={className}
-      href={`${href}?utm_source=create-turbo&utm_medium=basic&utm_campaign=create-turbo"`}
-      rel="noopener noreferrer"
-      target="_blank"
-    >
-      <h2>
-        {title} <span>-&gt;</span>
-      </h2>
-      <p>{children}</p>
-    </a>
-  );
-}

package/src/code.tsx

@@ -1,9 +0,0 @@
-export function Code({
-  children,
-  className,
-}: {
-  children: React.ReactNode;
-  className?: string;
-}): JSX.Element {
-  return <code className={className}>{children}</code>;
-}

package/src/hooks/alquimia.hook.tsx

@@ -1,239 +0,0 @@
-import { Message } from "ai";
-
-import { useEffect, useState } from "react";
-import { AlquimiaSDK } from "../sdk";
-import { AIMessageChunk, AlquimiaMessage } from "../types/type";
-import { createMessageId } from "../utils";
-export function useAlquimia(sdk: AlquimiaSDK) {
-  const [chunkReceived, setChunkReceived] = useState<string>("");
-  const [currentMessageIdChuncked, setCurrentMessageIdChuncked] =
-    useState<string>("");
-  const [input, setInput] = useState<string>("");
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [isMessageStreaming, setIsMessageStreaming] = useState<boolean>(false);
-  const [streamingMessageId, setStreamingMessageId] = useState<string | null>(null);
-  const [isAudioRecording, setIsAudioRecording] = useState<boolean>(false);
-  const [messageMetaData, setMessageMetaData] = useState<any>(null);
-  const [messages, setMessages] = useState<AlquimiaMessage[]>([]);
-  const [sessionId, setSessionId] = useState<string | null>(null);
-  const [activeTool, setActiveTool] = useState<any | null>(null);
-  const [lastRequest, setLastRequest] = useState<string | null>(null);
-
-
-  useEffect(() => {
-    if (chunkReceived)
-      processMessageChunk(currentMessageIdChuncked, chunkReceived);
-  }, [chunkReceived]);
-
-
-  function cleanMessages() {
-    setMessages([]);
-  }
-  async function processMessageChunk(
-    messageId: string,
-    chunk: string,
-    error_code?: string,
-    error_detail?: string,
-    additionalInfo?: string,
-    loading?: boolean
-  ) {
-    setMessages((currentMessages) => {
-      const messageIndex = currentMessages.findIndex(
-        (message) => message?.id === messageId
-      );
-      if (messageIndex !== -1) {
-        const updatedMessages = [...currentMessages];
-
-        const updatedMessage: AlquimiaMessage = {
-          ...updatedMessages[messageIndex],
-          content: `${updatedMessages[messageIndex]?.content || ""}${chunk}`,
-          id: updatedMessages[messageIndex]?.id || "",
-          role: updatedMessages[messageIndex]?.role || "assistant",
-          error_code,
-          error_detail,
-          additionalInfo,
-          created_at: new Date().getTime().toString(),
-          loading,
-        };
-        updatedMessages[messageIndex] = updatedMessage;
-        return updatedMessages;
-      } else {
-        return [
-          ...currentMessages,
-          {
-            content: `${chunk}`,
-            role: "assistant",
-            id: messageId,
-            error_code,
-            error_detail,
-            created_at: new Date().getTime().toString(),
-            loading,
-          },
-        ];
-      }
-    });
-  }
-
-  async function handleSubmit(event: React.FormEvent<HTMLFormElement>, traceParentId?: string, sessionId?: string, additionalInfo?: string) {
-    setIsLoading(true);
-    event.preventDefault();
-  
-    if (input) {
-      addUserMessage(input);
-      const messageId = createMessageId();
-      setCurrentMessageIdChuncked(messageId);
-      setStreamingMessageId(messageId);
-      await sendMessage(input, (chunk: AIMessageChunk) => {
-        processMessageChunk(
-          messageId,
-          chunk?.data?.content || "",
-          chunk?.error_code,
-          chunk?.error_detail,
-          additionalInfo,
-          chunk?.loading
-        );
-      }, traceParentId, sessionId);
-      setInput("");
-    }
-    setIsLoading(false);
-  }
-
-  function handleInputChange(event: React.ChangeEvent<HTMLInputElement>) {
-    setInput(event.target.value);
-  }
-
-  function handleReplaceInput(input: string) {
-    setInput(input);
-  }
-
-  function populateMessages(messages: Message[]) {
-    setMessages(messages);
-  }
-
-  function handleLoadingCancel() {
-    setIsLoading(false);
-    setIsMessageStreaming(false);
-    setInput("");
-  }
-
-  function addUserMessage(message: string) {
-    setMessages((prevMessages: AlquimiaMessage[]) => [
-      ...prevMessages,
-      {
-        content: message,
-        role: "user",
-        id: createMessageId(),
-        created_at: new Date().getTime().toString(),
-      },
-    ]);
-  }
-
-  function getCookie(name: string): string | null {
-    const cookies = document.cookie.split(";");
-    for (let cookie of cookies) {
-      const [cookieName, cookieValue] = cookie.trim().split("=");
-      if (cookieName === name) {
-        return decodeURIComponent(cookieValue as string);
-      }
-    }
-    return null;
-  }
-
-  async function sendMessage(
-    message: string,
-    callBack: (chunk: AIMessageChunk) => void,
-    traceParentId?: string,
-    sessionId?: string
-  ) {          
-    callBack({
-      type: "loading",
-      loading: true,
-    });
-    const conversationId = sessionId || getCookie("alquimia-session");
-    setIsMessageStreaming(true);
-    setActiveTool(null);
-    setLastRequest(message);
-
-    try {
-      const response = await sdk
-        .widthConversationId(conversationId || "")
-        .sendMessage(message, traceParentId);
-      const eventSource = new EventSource(response.getUrlStream());
-
-      const cleanup = (isStreaming: boolean) => {
-        setIsMessageStreaming(isStreaming);
-        setStreamingMessageId(null);
-        eventSource.close();
-      };
-
-      eventSource.onmessage = (event: MessageEvent) => {
-        const parsedData = JSON.parse(event.data);
-
-        if (parsedData.tooler?.length > 0 && !activeTool) {
-          setActiveTool({ tooler: parsedData.tooler });
-        }
-
-        if (parsedData.error_code) {
-          callBack({
-            type: "error",
-            error_code: parsedData.error_code,
-            error_detail: parsedData.error_detail,
-          });
-          cleanup(false);
-          return;
-        }
-
-        if (parsedData.is_complete) {
-          cleanup(false);
-        } else {
-          callBack(parsedData.answer);
-        }
-      };
-
-      eventSource.onerror = (event: Event) => {
-        console.error("Stream connection error", event);
-        cleanup(false);
-        callBack({
-          type: "error",
-          error_code: "STREAM_ERROR",
-          error_detail: "Failed to establish stream connection.",
-        });
-      };
-    } catch (error: any) {
-      console.error("Error sending message:", error);
-      setIsMessageStreaming(false);
-      setStreamingMessageId(null);
-      callBack({
-        type: "error",
-        error_code: error.status?.toString() || "REQUEST_ERROR",
-        error_detail: error.message || "Error initiating the stream.",
-      });
-    }
-  }
-
-  return {
-    activeTool,
-    cleanMessages,
-    createMessageId,
-    handleInputChange,
-    handleReplaceInput,
-    handleSubmit,
-    handleLoadingCancel,
-    input,
-    isLoading,
-    isMessageStreaming,
-    streamingMessageId,
-    isAudioRecording,
-    lastRequest,
-    messageMetaData,
-    messages,
-    populateMessages,
-    processMessageChunk,
-    sendMessage,
-    sessionId,
-    setActiveTool,
-    setSessionId,
-    setLastRequest,
-    setIsAudioRecording,
-  };
-}

package/src/hooks/index.ts

@@ -1,2 +0,0 @@
-export { useAlquimia } from "./alquimia.hook";
-export { useRatings } from "./useRatings";