@fencyai/react 0.1.82 → 0.1.83

package/lib/hooks/useStream/toStreamData.js

@@ -1,116 +0,0 @@
-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);
-        case 'FileSearchIndexReady':
-            return toFileSearchIndexReady(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,
-    };
-};
-const toFileSearchIndexReady = (data) => {
-    return {
-        type: 'FileSearchIndexReady',
-        streamId: data.streamId,
-        fileId: data.fileId,
-        timestamp: data.timestamp,
-    };
-};

package/lib/hooks/useStreamingChatCompletions/index.js

@@ -1,205 +0,0 @@
-import { createChatCompletion } from '@fencyai/js';
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useFencyContext } from '../../provider/useFencyContext';
-import { toSpecificChatCompletionParams } from '../../types/CreateGenericChatCompletionParams';
-import { useStream } from '../useStream';
-export const useStreamingChatCompletions = (props) => {
-    const context = useFencyContext();
-    const [chatCompletions, setChatCompletions] = useState([]);
-    const [completedStreamIds, setCompletedStreamIds] = useState([]);
-    const [chunks, setChunks] = useState([]);
-    const { createStream } = useStream({
-        onNewChatCompletionStreamChunk: (streamData) => {
-            props?.onChatCompletionStreamChunk?.(streamData);
-            setChunks((prev) => [...prev, streamData]);
-        },
-        onChatCompletionStreamCompleted: (stream) => {
-            props?.onChatCompletionStreamCompleted?.(stream);
-            setCompletedStreamIds((prev) => [...prev, stream.streamId]);
-        },
-        onStreamError: (error) => {
-            props?.onStreamError?.(error);
-            setChatCompletions((prev) => {
-                const existing = prev.find((c) => c.streamId === error.streamId);
-                if (!existing)
-                    return prev;
-                return [
-                    ...prev.filter((c) => c.streamId === error.streamId),
-                    {
-                        ...existing,
-                        loading: false,
-                        error: error.error,
-                    },
-                ];
-            });
-        },
-        onStreamNotFound: (error) => {
-            props?.onStreamNotFound?.(error);
-        },
-        onStreamTimeout: (error) => {
-            props?.onStreamTimeout?.(error);
-        },
-    });
-    useEffect(() => {
-        setChatCompletions((prev) => {
-            return prev.map((chatCompletion) => {
-                if (completedStreamIds.includes(chatCompletion.streamId)) {
-                    return {
-                        ...chatCompletion,
-                        doneStreaming: true,
-                        loading: false,
-                    };
-                }
-                return chatCompletion;
-            });
-        });
-    }, [completedStreamIds]);
-    useEffect(() => {
-        const newChatCompletions = [];
-        for (const chatCompletion of chatCompletions) {
-            const relevantChunks = chunks
-                .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,
-                        createdAt: chatCompletion.data.createdAt,
-                        streamId: chatCompletion.data.streamId,
-                    }
-                    : null,
-                streamId: chatCompletion.streamId,
-                error: chatCompletion.error,
-                prompt: chatCompletion.prompt,
-                loading: chatCompletion.loading,
-                doneStreaming: chatCompletion.doneStreaming,
-                response: fullMessage,
-                chunks: relevantChunks,
-            });
-        }
-        setChatCompletions(newChatCompletions);
-    }, [chunks]);
-    const createStreamingChatCompletion = useCallback(async (params) => {
-        // Step 1: Create stream if not exists
-        const streamResponse = await createStream({
-            type: 'ChatCompletionStream',
-        });
-        if (streamResponse.type === 'success') {
-            setChatCompletions([
-                ...chatCompletions,
-                {
-                    streamId: streamResponse.stream.id,
-                    triggeredAt: new Date().toISOString(),
-                    data: null,
-                    error: null,
-                    prompt: params,
-                    response: '',
-                    chunks: [],
-                    loading: true,
-                    doneStreaming: false,
-                },
-            ]);
-            const specificParams = toSpecificChatCompletionParams(params.openai, params.gemini, params.claude, params.generic);
-            // Step 2: Send chat completion
-            const chatCompletion = await createChatCompletion({
-                pk: context.fency.publishableKey,
-                baseUrl: context.fency.baseUrl,
-                request: {
-                    streamId: streamResponse.stream.id,
-                    ...specificParams,
-                },
-            });
-            if (chatCompletion.type === 'success' &&
-                chatCompletion.completion) {
-                setChatCompletions((prev) => [
-                    ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
-                    {
-                        streamId: streamResponse.stream.id,
-                        triggeredAt: new Date().toISOString(),
-                        data: {
-                            id: chatCompletion.completion.id,
-                            createdAt: chatCompletion.completion.createdAt,
-                            streamId: streamResponse.stream.id,
-                        },
-                        error: null,
-                        prompt: params,
-                        response: '',
-                        chunks: [],
-                        doneStreaming: false,
-                        loading: true,
-                    },
-                ]);
-                return {
-                    type: 'success',
-                    streamId: streamResponse.stream.id,
-                    chatCompletionId: chatCompletion.completion.id,
-                };
-            }
-            else if (chatCompletion.type === 'error') {
-                setChatCompletions((prev) => [
-                    ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
-                    {
-                        triggeredAt: new Date().toISOString(),
-                        streamId: streamResponse.stream.id,
-                        prompt: params,
-                        error: chatCompletion.error,
-                        response: '',
-                        chunks: [],
-                        loading: false,
-                        doneStreaming: false,
-                        data: null,
-                    },
-                ]);
-                return {
-                    type: 'error',
-                    error: chatCompletion.error,
-                };
-            }
-            else {
-                const error = {
-                    message: 'No response received',
-                    code: 'UnknownError',
-                };
-                setChatCompletions((prev) => [
-                    ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
-                    {
-                        triggeredAt: new Date().toISOString(),
-                        streamId: streamResponse.stream.id,
-                        error: error,
-                        prompt: params,
-                        response: '',
-                        chunks: [],
-                        loading: false,
-                        doneStreaming: false,
-                        data: null,
-                    },
-                ]);
-                return {
-                    type: 'error',
-                    error: error,
-                };
-            }
-        }
-        else {
-            console.error(streamResponse.error);
-            return streamResponse;
-        }
-    }, [context, chatCompletions]);
-    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,124 +0,0 @@
-import { createChatCompletion } from '@fencyai/js';
-import { useCallback, useMemo, useState } from 'react';
-import { z } from 'zod';
-import { useFencyContext } from '../../provider/useFencyContext';
-import { toSpecificChatCompletionParams } from '../../types/CreateGenericChatCompletionParams';
-export const useStructuredChatCompletions = () => {
-    const context = useFencyContext();
-    const [chatCompletions, setChatCompletions] = useState([]);
-    const createStructuredChatCompletion = useCallback(async (params) => {
-        const triggeredAt = new Date().toISOString();
-        setChatCompletions((prev) => [
-            ...prev,
-            {
-                triggeredAt,
-                data: null,
-                error: null,
-                loading: true,
-            },
-        ]);
-        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 specificParams = toSpecificChatCompletionParams(params.openai, params.gemini, params.claude, params.generic);
-        const response = await createChatCompletion({
-            pk: context.fency.publishableKey,
-            baseUrl: context.fency.baseUrl,
-            request: {
-                openai: specificParams.openai
-                    ? {
-                        responseJsonSchema: parsedJsonSchema,
-                        ...specificParams.openai,
-                    }
-                    : undefined,
-                gemini: specificParams.gemini
-                    ? {
-                        responseJsonSchema: parsedJsonSchema,
-                        ...specificParams.gemini,
-                    }
-                    : undefined,
-                claude: specificParams.claude
-                    ? {
-                        ...specificParams.claude,
-                    }
-                    : undefined,
-            },
-        });
-        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: structuredResponse,
-                    structuredResponse: structuredResponse,
-                };
-                const structuredChatCompletion = {
-                    triggeredAt,
-                    data: data,
-                    error: null,
-                    loading: false,
-                };
-                setChatCompletions((prev) => [
-                    ...prev.filter((c) => c.triggeredAt !== triggeredAt),
-                    structuredChatCompletion,
-                ]);
-                return {
-                    type: 'success',
-                    data: data,
-                };
-            }
-            else {
-                const error = {
-                    code: 'NoResponse',
-                    message: 'No response from chat completion',
-                };
-                setChatCompletions((prev) => [
-                    ...prev.filter((c) => c.triggeredAt !== triggeredAt),
-                    {
-                        triggeredAt,
-                        data: null,
-                        error: error,
-                        loading: false,
-                    },
-                ]);
-                return {
-                    type: 'error',
-                    error: error,
-                };
-            }
-        }
-        else {
-            setChatCompletions((prev) => [
-                ...prev.filter((c) => c.triggeredAt !== triggeredAt),
-                {
-                    triggeredAt,
-                    data: null,
-                    error: response.error,
-                    loading: false,
-                },
-            ]);
-            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.js

@@ -1,55 +0,0 @@
-import { createWebsite as createWebsiteApi, } from '@fencyai/js';
-import { useState } from 'react';
-import { useFencyContext } from '../../provider/useFencyContext';
-import { useStream } from '../useStream';
-export function useWebsites(props) {
-    const context = useFencyContext();
-    const [websites, setWebsites] = useState([]);
-    const { createStream } = useStream({
-        onWebsiteHtmlContentReady: (streamData) => {
-            props?.onHtmlContentReady?.(streamData);
-            setWebsites((prev) => prev.map((website) => {
-                return website.id === streamData.websiteId
-                    ? { ...website, htmlContent: streamData.htmlContent }
-                    : website;
-            }));
-        },
-        onWebsiteTextContentReady: (streamData) => {
-            props?.onTextContentReady?.(streamData);
-            setWebsites((prev) => prev.map((website) => website.id === streamData.websiteId
-                ? { ...website, textContent: streamData.textContent }
-                : website));
-        },
-    });
-    const createWebsite = async (params) => {
-        const stream = await createStream({
-            type: 'ChatCompletionStream',
-        });
-        if (stream.type === 'success') {
-            const response = await createWebsiteApi({
-                pk: context.fency.publishableKey,
-                request: {
-                    url: params.url,
-                    streamId: stream.stream.id,
-                    extractHtmlContent: params.extractHtmlContent || true,
-                    extractTextContent: params.extractTextContent || true,
-                },
-                baseUrl: context.fency.baseUrl,
-            });
-            if (response.type === 'success') {
-                setWebsites([...websites, response.website]);
-            }
-            return response;
-        }
-        else {
-            return {
-                type: 'error',
-                error: stream.error,
-            };
-        }
-    };
-    return {
-        createWebsite,
-        websites,
-    };
-}

package/lib/index.js

@@ -1,14 +0,0 @@
-// Re-export components and hooks
-export { useBasicChatCompletions } from './hooks/useBasicChatCompletions';
-export { useSearchFiles } from './hooks/useSearchFiles';
-export { useCreateFiles } from './hooks/useCreateFiles';
-export { useListFiles } from './hooks/useListFiles';
-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
-export * from './types';

package/lib/provider/FencyContextValue.js

@@ -1,3 +0,0 @@
-import { createContext } from 'react';
-// Create the context
-export const FencyContextValue = createContext(undefined);

package/lib/provider/FencyProvider.js

@@ -1,32 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { FencyContextValue } from './FencyContextValue';
-export function FencyProvider({ fency, children }) {
-    const [fencyInstance, setFencyInstance] = useState(null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        fency
-            .then((instance) => {
-            setFencyInstance(instance);
-            setLoading(false);
-        })
-            .catch((err) => {
-            setError(err);
-            setLoading(false);
-        });
-    }, [fency]);
-    if (error) {
-        return _jsxs("div", { children: ["Fency error: ", error.message] });
-    }
-    // Only render children and provide context when fency is loaded
-    if (!fencyInstance) {
-        return null;
-    }
-    const value = {
-        fency: fencyInstance,
-        loading,
-        error,
-    };
-    return (_jsx(FencyContextValue.Provider, { value: value, children: children }));
-}

package/lib/provider/useFencyContext.js

@@ -1,12 +0,0 @@
-import { useContext } from 'react';
-import { FencyContextValue } from './FencyContextValue';
-/**
- * Hook to access Fency instance and loading state
- */
-export function useFencyContext() {
-    const context = useContext(FencyContextValue);
-    if (context === undefined) {
-        throw new Error('useFencyContext must be used within a FencyProvider');
-    }
-    return context;
-}

package/lib/types/AiModel.d.ts

@@ -1,4 +0,0 @@
-import { OpenAiModel } from '@fencyai/js';
-import { GeminiModel } from '@fencyai/js';
-import { AnthropicModel } from '@fencyai/js';
-export type AiModel = OpenAiModel | GeminiModel | AnthropicModel;

package/lib/types/AiModel.js

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

package/lib/types/BasicChatCompletion.js

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

package/lib/types/BasicChatCompletionData.js

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

package/lib/types/BasicChatCompletionResponse.js

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

package/lib/types/CreateBasicChatCompletionParams.js

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

package/lib/types/CreateClaudeChatCompletionParams.js

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

package/lib/types/CreateFileParams.js

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

package/lib/types/CreateGeminiChatCompletionParams.js

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