@fencyai/react 0.1.48 → 0.1.50

package/lib/hooks/useBasicChatCompletions/index.js

@@ -1,5 +1,5 @@
 import { createChatCompletion } from '@fencyai/js';
-import { useCallback, useState } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { useFencyContext } from '../../provider/useFencyContext';
 export const useBasicChatCompletions = () => {
     const context = useFencyContext();
@@ -101,8 +101,14 @@ export const useBasicChatCompletions = () => {
             };
         }
     }, [context]);
+    const latest = useMemo(() => {
+        return chatCompletions.sort((a, b) => {
+            return new Date(b.triggeredAt).getTime() - new Date(a.triggeredAt).getTime();
+        })[0];
+    }, [chatCompletions]);
     return {
         chatCompletions,
         createBasicChatCompletion,
+        latest,
     };
 };

package/lib/hooks/useFencyEventSource/index.d.ts

@@ -0,0 +1,12 @@
+export type Message = {
+    url: string;
+    data: string;
+};
+export declare function useFencyEventSource(props?: {
+    onError: (streamId: string) => void;
+    onMessage: (message: Message) => boolean | void;
+}): {
+    setSourceUrl: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    sourceUrl: string | null;
+};
+export declare function base64Decode(base64: string): string;

package/lib/hooks/{useEventSource → useFencyEventSource}/index.js

@@ -1,31 +1,32 @@
 import { useEffect, useState } from 'react';
-export function useEventSource(props) {
-    const [source, setSource] = useState(null);
+export function useFencyEventSource(props) {
+    const [sourceUrl, setSourceUrl] = useState(null);
     useEffect(() => {
-        if (!source)
+        if (!sourceUrl) {
             return;
-        const eventSource = new EventSource(source.url);
+        }
+        const eventSource = new EventSource(sourceUrl);
         eventSource.onmessage = (message) => {
             props?.onMessage({
-                url: source.url,
+                url: sourceUrl,
                 data: base64Decode(message.data),
             });
         };
         eventSource.onerror = (error) => {
             console.error('EventSource error:', error);
-            props?.onError(source.url);
-            setSource(null);
+            props?.onError(sourceUrl);
+            setSourceUrl(null);
         };
         return () => {
             eventSource.close();
         };
-    }, [source]);
+    }, [sourceUrl]);
     return {
-        setSource,
-        source,
+        setSourceUrl,
+        sourceUrl,
     };
 }
-function base64Decode(base64) {
+export function base64Decode(base64) {
     // Decode Base64 -> binary string
     const binary = atob(base64);
     // Convert binary string -> Uint8Array

package/lib/hooks/useFiles/index.js

@@ -1,66 +1,61 @@
-import { createUpload } from '@fencyai/js';
+import { createFile as createFileApi, } from '@fencyai/js';
 import { useState } from 'react';
 import { useFencyContext } from '../../provider/useFencyContext';
 import { useStream } from '../useStream';
 export function useFiles(props) {
-    const [fileUploads, setFileUploads] = useState([]);
+    const [files, setFiles] = useState([]);
     const context = useFencyContext();
     const { createStream } = useStream({
         onFileUploadCompleted: (streamData) => {
             props.onUploadCompleted?.(streamData);
-            setFileUploads((prev) => prev.map((fileUpload) => {
-                return fileUpload.upload.id === streamData.uploadId
+            setFiles((prev) => prev.map((fileUpload) => {
+                return fileUpload.id === streamData.uploadId
                     ? { ...fileUpload, status: 'upload_complete' }
                     : fileUpload;
             }));
         },
         onFileTextContentReady: (streamData) => {
             props.onTextContentReady?.(streamData);
-            setFileUploads((prev) => prev.map((fileUpload) => fileUpload.upload.id === streamData.uploadId
-                ? { ...fileUpload, textContent: streamData.text }
+            setFiles((prev) => prev.map((fileUpload) => fileUpload.id === streamData.fileId
+                ? { ...fileUpload, textContent: streamData.textContent }
                 : fileUpload));
         },
     });
-    const createFileUpload = async (params) => {
-        const stream = await createStream({
+    const createFile = async (params) => {
+        const streamResponse = await createStream({
             type: 'FileStream',
         });
-        if (stream.type === 'success') {
-            const response = await createUpload({
+        if (streamResponse.type === 'success') {
+            const fileResponse = await createFileApi({
                 pk: context.fency.publishableKey,
                 request: {
-                    streamId: stream.stream.id,
+                    streamId: streamResponse.stream.id,
                     fileName: params.fileName,
                     fileType: params.fileType,
                     fileSize: params.fileSize,
                 },
                 baseUrl: context.fency.baseUrl,
             });
-            if (response.type === 'success') {
-                setFileUploads([
-                    ...fileUploads,
-                    {
-                        status: 'uploading',
-                        upload: response.upload,
-                        file: null,
-                        error: null,
-                        textContent: null,
-                        onUploadCompleted: props.onUploadCompleted,
-                        onTextContentReady: props.onTextContentReady,
-                    },
-                ]);
+            if (fileResponse.type === 'success') {
+                setFiles([...files, fileResponse.file]);
+                return fileResponse;
+            }
+            else {
+                return {
+                    type: 'error',
+                    error: fileResponse.error,
+                };
             }
-            return response;
         }
         else {
             return {
                 type: 'error',
-                error: stream.error,
+                error: streamResponse.error,
             };
         }
     };
     return {
-        createFileUpload,
-        fileUploads,
+        createFile,
+        files,
     };
 }

package/lib/hooks/useStream/index.js

@@ -1,11 +1,12 @@
 import { createStream as createStreamApi, } from '@fencyai/js';
 import { useState } from 'react';
 import { useFencyContext } from '../../provider/useFencyContext';
-import { useEventSource } from '../useEventSource';
+import { useFencyEventSource } from '../useFencyEventSource';
+import { toStreamData } from './toStreamData';
 export const useStream = (props) => {
     const context = useFencyContext();
     const [stream, setStream] = useState(null);
-    const eventSource = useEventSource({
+    const es = useFencyEventSource({
         onError: (url) => {
             console.error('Stream error:', url);
             props?.onStreamError?.({
@@ -58,9 +59,7 @@ export const useStream = (props) => {
         if (response.type === 'success') {
             setStream(response.stream);
             const url = `${context.fency.baseUrl}/v1/pub/streams/${response.stream.id}?pk=${context.fency.publishableKey}`;
-            eventSource.setSource({
-                url,
-            });
+            es.setSourceUrl(url);
         }
         return response;
     };
@@ -69,23 +68,3 @@ export const useStream = (props) => {
         stream,
     };
 };
-const toStreamData = (data) => {
-    try {
-        const json = JSON.parse(data);
-        if (isStreamData(json)) {
-            return json;
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('Error parsing message:', error);
-        return null;
-    }
-};
-const isStreamData = (data) => {
-    return (typeof data === 'object' &&
-        data !== null &&
-        'type' in data &&
-        'streamId' in data &&
-        'timestamp' in data);
-};

package/lib/hooks/useStream/toStreamData.d.ts

@@ -0,0 +1,2 @@
+import { StreamData } from '../../types/StreamData';
+export declare const toStreamData: (data: string) => StreamData | null;

package/lib/hooks/useStream/toStreamData.js

@@ -0,0 +1,106 @@
+export const toStreamData = (data) => {
+    try {
+        const json = JSON.parse(data);
+        return toStreamDataRaw(json);
+    }
+    catch (error) {
+        console.error('Error parsing message:', error);
+        return null;
+    }
+};
+const toStreamDataRaw = (data) => {
+    const basicTypeExist = typeof data === 'object' &&
+        data !== null &&
+        'type' in data &&
+        'streamId' in data &&
+        'timestamp' in data;
+    if (!basicTypeExist) {
+        return null;
+    }
+    switch (data.type) {
+        case 'NewChatCompletionStreamChunk':
+            return toNewChatCompletionStreamChunk(data);
+        case 'ChatCompletionStreamCompleted':
+            return toChatCompletionStreamCompleted(data);
+        case 'StreamTimeout':
+            return toStreamTimeout(data);
+        case 'StreamNotFound':
+            return toStreamNotFound(data);
+        case 'FileUploadCompleted':
+            return toFileUploadCompleted(data);
+        case 'FileTextContentReady':
+            return toFileTextContentReady(data);
+        case 'WebsiteHtmlContentReady':
+            return toWebsiteHtmlContentReady(data);
+        case 'WebsiteTextContentReady':
+            return toWebsiteTextContentReady(data);
+    }
+    return null;
+};
+const toNewChatCompletionStreamChunk = (data) => {
+    return {
+        type: 'NewChatCompletionStreamChunk',
+        streamId: data.streamId,
+        chatCompletionId: data.chatCompletionId,
+        timestamp: data.timestamp,
+        content: data.content,
+    };
+};
+const toChatCompletionStreamCompleted = (data) => {
+    return {
+        type: 'ChatCompletionStreamCompleted',
+        streamId: data.streamId,
+        chatCompletionId: data.chatCompletionId,
+        timestamp: data.timestamp,
+    };
+};
+const toStreamTimeout = (data) => {
+    return {
+        type: 'StreamTimeout',
+        streamId: data.streamId,
+        timestamp: data.timestamp,
+    };
+};
+const toStreamNotFound = (data) => {
+    return {
+        type: 'StreamNotFound',
+        streamId: data.streamId,
+        timestamp: data.timestamp,
+    };
+};
+const toFileUploadCompleted = (data) => {
+    return {
+        type: 'FileUploadCompleted',
+        streamId: data.streamId,
+        uploadId: data.fileId,
+        fileId: data.fileId,
+        timestamp: data.timestamp,
+    };
+};
+const toFileTextContentReady = (data) => {
+    return {
+        type: 'FileTextContentReady',
+        streamId: data.streamId,
+        fileId: data.fileId,
+        textContent: data.textContent,
+        timestamp: data.timestamp,
+    };
+};
+const toWebsiteHtmlContentReady = (data) => {
+    return {
+        type: 'WebsiteHtmlContentReady',
+        streamId: data.streamId,
+        websiteId: data.websiteId,
+        htmlContent: data.htmlContent,
+        timestamp: data.timestamp,
+    };
+};
+const toWebsiteTextContentReady = (data) => {
+    return {
+        type: 'WebsiteTextContentReady',
+        streamId: data.streamId,
+        websiteId: data.websiteId,
+        textContent: data.textContent,
+        timestamp: data.timestamp,
+    };
+};

package/lib/hooks/useStreamingChatCompletions/index.js

@@ -1,7 +1,7 @@
 import { createChatCompletion } from '@fencyai/js';
-import { useCallback, useEffect, useState } from 'react';
-import { useStream } from '../useStream';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useFencyContext } from '../../provider/useFencyContext';
+import { useStream } from '../useStream';
 export const useStreamingChatCompletions = () => {
     const context = useFencyContext();
     const [chatCompletions, setChatCompletions] = useState([]);
@@ -9,9 +9,7 @@ export const useStreamingChatCompletions = () => {
     const [chunks, setChunks] = useState([]);
     const { stream, createStream } = useStream({
         onNewChatCompletionStreamChunk: (streamData) => {
-            if (streamData.type === 'NewChatCompletionStreamChunk') {
-                setChunks((prev) => [...prev, streamData]);
-            }
+            setChunks((prev) => [...prev, streamData]);
         },
         onChatCompletionStreamCompleted: (stream) => {
             setCompletedStreamIds((prev) => [...prev, stream.streamId]);
@@ -50,12 +48,15 @@ export const useStreamingChatCompletions = () => {
         const newChatCompletions = [];
         for (const chatCompletion of chatCompletions) {
             const relevantChunks = chunks
-                .filter((chunk) => chunk.chatCompletionId === chatCompletion.data?.id)
+                .filter((chunk) => {
+                return chunk.streamId === chatCompletion.streamId;
+            })
                 .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
             const fullMessage = relevantChunks
                 .map((chunk) => chunk.content)
                 .join('');
             newChatCompletions.push({
+                triggeredAt: chatCompletion.triggeredAt,
                 data: chatCompletion.data
                     ? {
                         id: chatCompletion.data.id,
@@ -83,6 +84,7 @@ export const useStreamingChatCompletions = () => {
                 ...chatCompletions,
                 {
                     streamId: streamResponse.stream.id,
+                    triggeredAt: new Date().toISOString(),
                     data: null,
                     error: null,
                     response: '',
@@ -120,8 +122,8 @@ export const useStreamingChatCompletions = () => {
             if (chatCompletion.type === 'success' &&
                 chatCompletion.completion) {
                 const newCompletion = {
-                    triggeredAt: new Date().toISOString(),
                     streamId: streamResponse.stream.id,
+                    triggeredAt: new Date().toISOString(),
                     data: {
                         id: chatCompletion.completion.id,
                         createdAt: chatCompletion.completion.createdAt,
@@ -147,6 +149,7 @@ export const useStreamingChatCompletions = () => {
                 setChatCompletions((prev) => [
                     ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
                     {
+                        triggeredAt: new Date().toISOString(),
                         streamId: streamResponse.stream.id,
                         error: chatCompletion.error,
                         response: '',
@@ -169,6 +172,7 @@ export const useStreamingChatCompletions = () => {
                 setChatCompletions((prev) => [
                     ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
                     {
+                        triggeredAt: new Date().toISOString(),
                         streamId: streamResponse.stream.id,
                         error: error,
                         response: '',
@@ -189,8 +193,15 @@ export const useStreamingChatCompletions = () => {
             return streamResponse;
         }
     }, [context]);
+    const latest = useMemo(() => {
+        return chatCompletions.sort((a, b) => {
+            return (new Date(b.triggeredAt).getTime() -
+                new Date(a.triggeredAt).getTime());
+        })[0];
+    }, [chatCompletions]);
     return {
         chatCompletions,
         createStreamingChatCompletion,
+        latest,
     };
 };

package/lib/hooks/useStructuredChatCompletions/index.js

@@ -1,5 +1,5 @@
 import { createChatCompletion } from '@fencyai/js';
-import { useCallback, useState } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { z } from 'zod';
 import { useFencyContext } from '../../provider/useFencyContext';
 export const useStructuredChatCompletions = () => {
@@ -17,6 +17,16 @@ export const useStructuredChatCompletions = () => {
             },
         ]);
         const jsonSchema = z.toJSONSchema(params.responseFormat);
+        const parseResponse = (response, params) => {
+            try {
+                return params.responseFormat.parse(JSON.parse(response));
+            }
+            catch (error) {
+                console.error('could not parse response', response);
+                console.error(error);
+                return null;
+            }
+        };
         const parsedJsonSchema = JSON.stringify(jsonSchema);
         const response = await createChatCompletion({
             pk: context.fency.publishableKey,
@@ -40,11 +50,12 @@ export const useStructuredChatCompletions = () => {
         });
         if (response.type === 'success') {
             if (response.completion.response) {
+                const structuredResponse = parseResponse(response.completion.response, params);
                 const data = {
                     id: response.completion.id,
                     createdAt: response.completion.createdAt,
-                    response: params.responseFormat.parse(JSON.parse(response.completion.response)),
-                    structuredResponse: params.responseFormat.parse(JSON.parse(response.completion.response)),
+                    response: structuredResponse,
+                    structuredResponse: structuredResponse,
                 };
                 const structuredChatCompletion = {
                     triggeredAt,
@@ -94,8 +105,15 @@ export const useStructuredChatCompletions = () => {
             return response;
         }
     }, [context]);
+    const latest = useMemo(() => {
+        return chatCompletions.sort((a, b) => {
+            return (new Date(b.triggeredAt).getTime() -
+                new Date(a.triggeredAt).getTime());
+        })[0];
+    }, [chatCompletions]);
     return {
         chatCompletions,
         createStructuredChatCompletion,
+        latest,
     };
 };

package/lib/hooks/useWebsites/index.d.ts

@@ -1,3 +1,3 @@
 import { UseWebsites } from '../../types/UseWebsites';
 import { UseWebsitesProps } from '../../types/UseWebsitesProps';
-export declare function useWebsites(props: UseWebsitesProps): UseWebsites;
+export declare function useWebsites(props?: UseWebsitesProps): UseWebsites;

package/lib/hooks/useWebsites/index.js

@@ -7,15 +7,15 @@ export function useWebsites(props) {
     const [websites, setWebsites] = useState([]);
     const { createStream } = useStream({
         onWebsiteHtmlContentReady: (streamData) => {
-            props.onHtmlContentReady?.(streamData);
+            props?.onHtmlContentReady?.(streamData);
             setWebsites((prev) => prev.map((website) => {
                 return website.id === streamData.websiteId
-                    ? { ...website, status: 'website_complete' }
+                    ? { ...website, htmlContent: streamData.htmlContent }
                     : website;
             }));
         },
         onWebsiteTextContentReady: (streamData) => {
-            props.onTextContentReady?.(streamData);
+            props?.onTextContentReady?.(streamData);
             setWebsites((prev) => prev.map((website) => website.id === streamData.websiteId
                 ? { ...website, textContent: streamData.textContent }
                 : website));

package/lib/index.d.ts

@@ -3,5 +3,7 @@ export { useFiles } from './hooks/useFiles';
 export { useStreamingChatCompletions } from './hooks/useStreamingChatCompletions';
 export { useStructuredChatCompletions } from './hooks/useStructuredChatCompletions';
 export { useWebsites } from './hooks/useWebsites';
+export { useStream } from './hooks/useStream';
+export { useFencyEventSource } from './hooks/useFencyEventSource';
 export { FencyProvider } from './provider/FencyProvider';
 export * from './types';

package/lib/index.js

@@ -4,6 +4,8 @@ export { useFiles } from './hooks/useFiles';
 export { useStreamingChatCompletions } from './hooks/useStreamingChatCompletions';
 export { useStructuredChatCompletions } from './hooks/useStructuredChatCompletions';
 export { useWebsites } from './hooks/useWebsites';
+export { useStream } from './hooks/useStream';
+export { useFencyEventSource } from './hooks/useFencyEventSource';
 // Re-export providers
 export { FencyProvider } from './provider/FencyProvider';
 // Re-export all types from centralized location

package/lib/types/{CreateUploadParams.d.ts → CreateFileParams.d.ts}

@@ -1,4 +1,4 @@
-export interface CreateUploadParams {
+export interface CreateFileParams {
     fileName: string;
     fileType: string;
     fileSize: number;

package/lib/types/StreamData.d.ts

@@ -0,0 +1,52 @@
+export type NewChatCompletionStreamChunk = {
+    type: 'NewChatCompletionStreamChunk';
+    streamId: string;
+    chatCompletionId: string;
+    timestamp: string;
+    content: string;
+};
+export type ChatCompletionStreamCompleted = {
+    type: 'ChatCompletionStreamCompleted';
+    streamId: string;
+    chatCompletionId: string;
+    timestamp: string;
+};
+export type StreamTimeout = {
+    type: 'StreamTimeout';
+    streamId: string;
+    timestamp: string;
+};
+export type StreamNotFound = {
+    type: 'StreamNotFound';
+    streamId: string;
+    timestamp: string;
+};
+export type FileUploadCompleted = {
+    type: 'FileUploadCompleted';
+    streamId: string;
+    uploadId: string;
+    fileId: string;
+    timestamp: string;
+};
+export type FileTextContentReady = {
+    type: 'FileTextContentReady';
+    streamId: string;
+    fileId: string;
+    textContent: string;
+    timestamp: string;
+};
+export type WebsiteHtmlContentReady = {
+    type: 'WebsiteHtmlContentReady';
+    streamId: string;
+    websiteId: string;
+    htmlContent: string;
+    timestamp: string;
+};
+export type WebsiteTextContentReady = {
+    type: 'WebsiteTextContentReady';
+    streamId: string;
+    websiteId: string;
+    textContent: string;
+    timestamp: string;
+};
+export type StreamData = NewChatCompletionStreamChunk | ChatCompletionStreamCompleted | StreamTimeout | StreamNotFound | FileUploadCompleted | FileTextContentReady | WebsiteHtmlContentReady | WebsiteTextContentReady;

package/lib/types/StreamingChatCompletion.d.ts

@@ -1,6 +1,8 @@
-import { ApiError, NewChatCompletionStreamChunk } from '@fencyai/js';
+import { ApiError } from '@fencyai/js';
 import { StreamingChatCompletionData } from './StreamingChatCompletionData';
+import { NewChatCompletionStreamChunk } from './StreamData';
 export interface StreamingChatCompletion {
+    triggeredAt: string;
     streamId: string;
     data: StreamingChatCompletionData | null;
     error: ApiError | null;

package/lib/types/UseBasicChatCompletions.d.ts

@@ -4,4 +4,5 @@ import { BasicChatCompletionResponse } from "./BasicChatCompletionResponse";
 export interface UseBasicChatCompletions {
     chatCompletions: BasicChatCompletion[];
     createBasicChatCompletion: (params: CreateBasicChatCompletionParams) => Promise<BasicChatCompletionResponse>;
+    latest: BasicChatCompletion | null;
 }

package/lib/types/UseFiles.d.ts

@@ -1,7 +1,6 @@
-import { CreateUploadResponse } from '@fencyai/js';
-import { CreateUploadParams } from './CreateUploadParams';
-import { FileUpload } from './FileUpload';
+import { CreateFileResponse, FencyFile } from '@fencyai/js';
+import { CreateFileParams } from './CreateFileParams';
 export interface UseFiles {
-    createFileUpload: (params: CreateUploadParams) => Promise<CreateUploadResponse>;
-    fileUploads: FileUpload[];
+    createFile: (params: CreateFileParams) => Promise<CreateFileResponse>;
+    files: FencyFile[];
 }

package/lib/types/UseFilesProps.d.ts

@@ -1,4 +1,4 @@
-import { FileTextContentReady, FileUploadCompleted } from '@fencyai/js/lib/types/StreamData';
+import { FileTextContentReady, FileUploadCompleted } from './StreamData';
 export interface UseFilesProps {
     onUploadCompleted?: (event: FileUploadCompleted) => void;
     onTextContentReady?: (event: FileTextContentReady) => void;

package/lib/types/UseStreamProps.d.ts

@@ -1,5 +1,4 @@
-import { ChatCompletionStreamCompleted, NewChatCompletionStreamChunk, StreamNotFound, StreamTimeout } from '@fencyai/js';
-import { FileUploadCompleted, FileTextContentReady, WebsiteHtmlContentReady, WebsiteTextContentReady } from '@fencyai/js/lib/types/StreamData';
+import { ChatCompletionStreamCompleted, NewChatCompletionStreamChunk, StreamNotFound, StreamTimeout, FileUploadCompleted, FileTextContentReady, WebsiteHtmlContentReady, WebsiteTextContentReady } from './StreamData';
 import { StreamError } from './StreamError';
 export interface UseStreamProps {
     onNewChatCompletionStreamChunk?: (streamData: NewChatCompletionStreamChunk) => void;

package/lib/types/UseStreamingChatCompletions.d.ts

@@ -4,4 +4,5 @@ import { StreamingChatCompletion } from "./StreamingChatCompletion";
 export interface UseStreamingChatCompletions {
     chatCompletions: StreamingChatCompletion[];
     createStreamingChatCompletion: (params: CreateStreamingChatCompletionParams) => Promise<CreateStreamingChatCompletionResponse>;
+    latest: StreamingChatCompletion | null;
 }

package/lib/types/UseStructuredChatCompletions.d.ts

@@ -5,4 +5,5 @@ import { StructuredChatCompletionResponse } from './StructuredChatCompletionResp
 export interface UseStructuredChatCompletions {
     chatCompletions: StructuredChatCompletion<ZodTypeAny>[];
     createStructuredChatCompletion: <T extends ZodTypeAny>(params: CreateStructuredChatCompletionParams<T>) => Promise<StructuredChatCompletionResponse<T>>;
+    latest: StructuredChatCompletion<ZodTypeAny> | null;
 }

package/lib/types/UseWebsites.d.ts

@@ -1,5 +1,6 @@
-import { CreateWebsiteRequest, CreateWebsiteResponse, Website } from '@fencyai/js';
+import { CreateWebsiteResponse, Website } from '@fencyai/js';
+import { CreateWebsiteParams } from './CreateWebsiteParams';
 export interface UseWebsites {
     websites: Website[];
-    createWebsite: (params: CreateWebsiteRequest) => Promise<CreateWebsiteResponse>;
+    createWebsite: (params: CreateWebsiteParams) => Promise<CreateWebsiteResponse>;
 }

package/lib/types/UseWebsitesProps.d.ts

@@ -1,4 +1,4 @@
-import { WebsiteHtmlContentReady, WebsiteTextContentReady } from '@fencyai/js/lib/types/StreamData';
+import { WebsiteHtmlContentReady, WebsiteTextContentReady } from './StreamData';
 export interface UseWebsitesProps {
     onHtmlContentReady?: (event: WebsiteHtmlContentReady) => void;
     onTextContentReady?: (event: WebsiteTextContentReady) => void;

package/lib/types/index.d.ts

@@ -7,19 +7,24 @@ export * from './BasicChatCompletionData';
 export * from './BasicChatCompletion';
 export * from './BasicChatCompletionResponse';
 export * from './CreateBasicChatCompletionParams';
+export * from './UseBasicChatCompletions';
 export * from './StreamingChatCompletionData';
 export * from './StreamingChatCompletion';
 export * from './CreateStreamingChatCompletionParams';
+export * from './CreateStreamingChatCompletionResponse';
+export * from './UseStreamingChatCompletions';
 export * from './StructuredChatCompletionData';
 export * from './StructuredChatCompletion';
 export * from './StructuredChatCompletionResponse';
 export * from './CreateStructuredChatCompletionParams';
+export * from './UseStructuredChatCompletions';
 export * from './UseStream';
 export * from './CreateStreamResponse';
 export * from './StreamError';
 export * from './UseStreamProps';
 export * from './UseFiles';
 export * from './UseFilesProps';
-export * from './FileUploadStatus';
-export * from './FileUpload';
+export * from './CreateFileParams';
 export * from './UseWebsites';
+export * from './UseWebsitesProps';
+export * from './CreateWebsiteParams';

package/lib/types/index.js

@@ -10,15 +10,19 @@ export * from './BasicChatCompletionData';
 export * from './BasicChatCompletion';
 export * from './BasicChatCompletionResponse';
 export * from './CreateBasicChatCompletionParams';
+export * from './UseBasicChatCompletions';
 // Streaming chat completion types
 export * from './StreamingChatCompletionData';
 export * from './StreamingChatCompletion';
 export * from './CreateStreamingChatCompletionParams';
+export * from './CreateStreamingChatCompletionResponse';
+export * from './UseStreamingChatCompletions';
 // Structured chat completion types
 export * from './StructuredChatCompletionData';
 export * from './StructuredChatCompletion';
 export * from './StructuredChatCompletionResponse';
 export * from './CreateStructuredChatCompletionParams';
+export * from './UseStructuredChatCompletions';
 // Stream types
 export * from './UseStream';
 export * from './CreateStreamResponse';
@@ -27,7 +31,8 @@ export * from './UseStreamProps';
 // File upload types
 export * from './UseFiles';
 export * from './UseFilesProps';
-export * from './FileUploadStatus';
-export * from './FileUpload';
+export * from './CreateFileParams';
 // Website types
 export * from './UseWebsites';
+export * from './UseWebsitesProps';
+export * from './CreateWebsiteParams';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fencyai/react",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "> TODO: description",
   "author": "staklau <steinaageklaussen@gmail.com>",
   "homepage": "",
@@ -36,7 +36,7 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@fencyai/js": "^0.1.48",
+    "@fencyai/js": "^0.1.50",
     "@types/jest": "^29.5.11",
     "@types/node": "^20.10.5",
     "@types/react": "^18.2.45",
@@ -45,8 +45,8 @@
     "typescript": "^5.3.3"
   },
   "peerDependencies": {
-    "@fencyai/js": "^0.1.48",
+    "@fencyai/js": "^0.1.50",
     "react": ">=16.8.0"
   },
-  "gitHead": "889ff241bad28cb096835f3e72389bfdcf1d51ee"
+  "gitHead": "d1be8f911659567ce9fb76fa130397a8ae8d38f3"
 }

package/lib/hooks/useEventSource/index.d.ts

@@ -1,14 +0,0 @@
-export type Message = {
-    url: string;
-    data: string;
-};
-export type EventSource = {
-    url: string;
-};
-export declare function useEventSource(props?: {
-    onError: (streamId: string) => void;
-    onMessage: (message: Message) => void;
-}): {
-    setSource: import("react").Dispatch<import("react").SetStateAction<EventSource | null>>;
-    source: EventSource | null;
-};

package/lib/types/FileUpload.d.ts

@@ -1,11 +0,0 @@
-import { ApiError, FencyFile, FileUploadCompleted, FileTextContentReady, Upload } from '@fencyai/js';
-import { FileUploadStatus } from './FileUploadStatus';
-export interface FileUpload {
-    status: FileUploadStatus;
-    upload: Upload;
-    file: FencyFile | null;
-    error: ApiError | null;
-    textContent: string | null;
-    onUploadCompleted?: (event: FileUploadCompleted) => void;
-    onTextContentReady?: (event: FileTextContentReady) => void;
-}

package/lib/types/FileUploadStatus.d.ts

@@ -1 +0,0 @@
-export type FileUploadStatus = 'uploading' | 'upload_failed' | 'upload_complete';

package/lib/types/FileUploadStatus.js

@@ -1 +0,0 @@
-export {};