@fencyai/react 0.1.32 → 0.1.34

package/lib/chat-completions/ChatCompletionProvider.d.ts

@@ -0,0 +1,22 @@
+import { FencyInstance } from '@fencyai/js';
+export declare const ChatCompletionContextValue: import("react").Context<ChatCompletionContext | undefined>;
+/**
+ * Provider component that provides Fency instance to child components
+ * Expects a promise that resolves to a Fency instance
+ */
+export declare function ChatCompletionProvider({ fency, children, }: ChatCompletionProviderProps): import("react/jsx-runtime").JSX.Element | null;
+export interface ChatCompletionContext {
+    fency: FencyInstance;
+    loading: boolean;
+    error: Error | null;
+}
+/**
+ * Props for ChatCompletionProvider
+ */
+export interface ChatCompletionProviderProps {
+    fency: Promise<FencyInstance>;
+    children: React.ReactNode;
+    options?: {
+        fetchClientSecret: () => Promise<string>;
+    };
+}

package/lib/{FencyProvider.js → chat-completions/ChatCompletionProvider.js}

@@ -1,12 +1,12 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useEffect, useState } from 'react';
 // Create the context
-export const FencyContextValue = createContext(undefined);
+export const ChatCompletionContextValue = createContext(undefined);
 /**
  * Provider component that provides Fency instance to child components
  * Expects a promise that resolves to a Fency instance
  */
-export function FencyProvider({ fency, children }) {
+export function ChatCompletionProvider({ fency, children, }) {
     const [fencyInstance, setFencyInstance] = useState(null);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
@@ -33,5 +33,5 @@ export function FencyProvider({ fency, children }) {
         loading,
         error,
     };
-    return (_jsx(FencyContextValue.Provider, { value: value, children: children }));
+    return (_jsx(ChatCompletionContextValue.Provider, { value: value, children: children }));
 }

package/lib/chat-completions/useChatCompletionContext.d.ts

@@ -0,0 +1,5 @@
+import type { ChatCompletionContext } from './ChatCompletionProvider';
+/**
+ * Hook to access Fency instance and loading state
+ */
+export declare function useChatCompletionContext(): ChatCompletionContext;

package/lib/chat-completions/useChatCompletionContext.js

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

package/lib/{hooks → chat-completions}/useChatCompletions.d.ts

@@ -10,21 +10,26 @@ interface Completions {
 }
 interface HookResponse {
     chatCompletions: Completions[];
-    createStreamingChatCompletion: (params: {
+    createChatCompletion: (params: {
         openai?: CreateOpenAiChatCompletionParams;
         gemini?: CreateGeminiChatCompletionParams;
         anthropic?: CreateAnthropicChatCompletionParams;
-    }) => Promise<{
-        chatCompletionStreamId: string;
-        chatCompletionId: string;
-    }>;
-    createSynchronousChatCompletion: <T extends ZodTypeAny>(params: {
+    }) => Promise<ChatCompletion>;
+    createStructuredChatCompletion: <T extends ZodTypeAny>(params: {
         openai?: CreateOpenAiChatCompletionParams;
         gemini?: CreateGeminiChatCompletionParams;
         anthropic?: CreateAnthropicChatCompletionParams;
-        responseFormat?: T;
+        responseFormat: T;
     }) => Promise<ChatCompletion & {
-        structuredResponse?: z.infer<T>;
+        structuredResponse: z.infer<T>;
+    }>;
+    createStreamingChatCompletion: (params: {
+        openai?: CreateOpenAiChatCompletionParams;
+        gemini?: CreateGeminiChatCompletionParams;
+        anthropic?: CreateAnthropicChatCompletionParams;
+    }) => Promise<{
+        chatCompletionStreamId: string;
+        chatCompletionId: string;
     }>;
     latestCompletion: Completions | null;
 }

package/lib/{hooks → chat-completions}/useChatCompletions.js

@@ -2,25 +2,24 @@
 import { createChatCompletion, createChatCompletionStream, } from '@fencyai/js';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import z from 'zod';
+import { useChatCompletionContext } from './useChatCompletionContext';
 import { useEventSource } from './useEventSource';
-import { useFency } from './useFency';
 export function useChatCompletions() {
-    const fency = useFency();
+    const context = useChatCompletionContext();
     const { chunks, setUrl } = useEventSource();
     const [chatCompletions, setChatCompletions] = useState([]);
     const [stream, setStream] = useState(null);
-    console.log('v2');
     const createStreamingChatCompletion = useCallback(async (params) => {
         // Step 1: Create stream if not exists
         const s = await createChatCompletionStream({
-            pk: fency.fency.publishableKey,
-            baseUrl: fency.fency.baseUrl,
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
         });
         setStream(s);
         // Step 2: Send chat completion
         const chatCompletion = await createChatCompletion({
-            pk: fency.fency.publishableKey,
-            baseUrl: fency.fency.baseUrl,
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
             request: {
                 streamId: s.id,
                 openai: params.openai
@@ -48,17 +47,41 @@ export function useChatCompletions() {
             chatCompletionStreamId: s.id,
             chatCompletionId: chatCompletion.id,
         };
-    }, [fency]);
+    }, [context]);
     const createSynchronousChatCompletion = useCallback(async (params) => {
-        const jsonSchema = params.responseFormat
-            ? z.toJSONSchema(params.responseFormat)
-            : undefined;
-        const parsedJsonSchema = jsonSchema
-            ? JSON.stringify(jsonSchema)
-            : undefined;
         const chatCompletion = await createChatCompletion({
-            pk: fency.fency.publishableKey,
-            baseUrl: fency.fency.baseUrl,
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
+            request: {
+                openai: params.openai
+                    ? {
+                        model: params.openai.model,
+                        messages: params.openai.messages,
+                    }
+                    : undefined,
+                gemini: params.gemini
+                    ? {
+                        model: params.gemini.model,
+                        content: params.gemini.content,
+                    }
+                    : undefined,
+                anthropic: params.anthropic
+                    ? {
+                        model: params.anthropic.model,
+                        messages: params.anthropic.messages,
+                    }
+                    : undefined,
+            },
+        });
+        setChatCompletions((prev) => [...prev, chatCompletion]);
+        return chatCompletion;
+    }, [context]);
+    const createStructuredChatCompletion = useCallback(async (params) => {
+        const jsonSchema = z.toJSONSchema(params.responseFormat);
+        const parsedJsonSchema = JSON.stringify(jsonSchema);
+        const chatCompletion = await createChatCompletion({
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
             request: {
                 openai: params.openai
                     ? {
@@ -83,16 +106,14 @@ export function useChatCompletions() {
             },
         });
         setChatCompletions((prev) => [...prev, chatCompletion]);
-        if (chatCompletion.responseIsStructured &&
-            params.responseFormat &&
-            chatCompletion.response) {
+        if (chatCompletion.response) {
             return {
                 ...chatCompletion,
                 structuredResponse: params.responseFormat.parse(JSON.parse(chatCompletion.response)),
             };
         }
-        return chatCompletion;
-    }, [fency]);
+        throw new Error('No response from chat completion');
+    }, [context]);
     const completions = useMemo(() => {
         const completions = [];
         for (const chatCompletion of chatCompletions) {
@@ -115,12 +136,13 @@ export function useChatCompletions() {
     }, [completions]);
     useEffect(() => {
         if (stream) {
-            setUrl(`${fency.fency.baseUrl}/v1/pub/chat-completion-streams/${stream.id}?pk=${fency.fency.publishableKey}`);
+            setUrl(`${context.fency.baseUrl}/v1/pub/chat-completion-streams/${stream.id}?pk=${context.fency.publishableKey}`);
         }
-    }, [stream, fency.fency.publishableKey, setUrl]);
+    }, [stream, context.fency.publishableKey, setUrl]);
     return {
+        createChatCompletion: createSynchronousChatCompletion,
+        createStructuredChatCompletion: createStructuredChatCompletion,
         createStreamingChatCompletion: createStreamingChatCompletion,
-        createSynchronousChatCompletion: createSynchronousChatCompletion,
         chatCompletions: completions,
         latestCompletion,
     };

package/lib/{hooks → chat-completions}/useEventSource.js

@@ -6,17 +6,24 @@ export function useEventSource() {
         if (!url)
             return;
         const eventSource = new EventSource(url);
-        eventSource.onmessage = (event) => {
-            const chunk = getChatCompletionChunk(event);
+        eventSource.onmessage = (message) => {
+            if (message.data === '__END_OF_STREAM__') {
+                eventSource.close();
+                setUrl(null); // Clear URL to prevent reconnection
+                return;
+            }
+            const chunk = getChatCompletionChunk(message);
             if (chunk) {
                 setChunks((prev) => [...prev, chunk]);
             }
             else {
-                console.warn('Unknown message:', event);
+                console.warn('Unknown message:', message);
             }
         };
         eventSource.onerror = (error) => {
             console.error('EventSource error:', error);
+            eventSource.close();
+            setUrl(null); // Clear URL on error
         };
         return () => {
             eventSource.close();

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-export { FencyProvider } from './FencyProvider';
-export { useChatCompletions } from './hooks/useChatCompletions';
-export { useFency } from './hooks/useFency';
-export type { FencyContext, FencyProviderProps } from './FencyProvider';
+export { ChatCompletionProvider } from './chat-completions/ChatCompletionProvider';
+export { useChatCompletionContext } from './chat-completions/useChatCompletionContext';
+export { useChatCompletions } from './chat-completions/useChatCompletions';
+export type { ChatCompletionContext, ChatCompletionProviderProps, } from './chat-completions/ChatCompletionProvider';

package/lib/index.js

@@ -1,4 +1,4 @@
 // Re-export components and hooks
-export { FencyProvider } from './FencyProvider';
-export { useChatCompletions } from './hooks/useChatCompletions';
-export { useFency } from './hooks/useFency';
+export { ChatCompletionProvider } from './chat-completions/ChatCompletionProvider';
+export { useChatCompletionContext } from './chat-completions/useChatCompletionContext';
+export { useChatCompletions } from './chat-completions/useChatCompletions';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fencyai/react",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "> TODO: description",
   "author": "staklau <steinaageklaussen@gmail.com>",
   "homepage": "",
@@ -36,7 +36,7 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@fencyai/js": "^0.1.32",
+    "@fencyai/js": "^0.1.34",
     "@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.32",
+    "@fencyai/js": "^0.1.34",
     "react": ">=16.8.0"
   },
-  "gitHead": "a487d68673a259c2490b83a9a6fba991ea02d034"
+  "gitHead": "a4dcf1572fcf4587355ffe38e6971b18025e4568"
 }

package/lib/FencyProvider.d.ts

@@ -1,19 +0,0 @@
-import { FencyInstance } from '@fencyai/js';
-export declare const FencyContextValue: import("react").Context<FencyContext | undefined>;
-/**
- * Provider component that provides Fency instance to child components
- * Expects a promise that resolves to a Fency instance
- */
-export declare function FencyProvider({ fency, children }: FencyProviderProps): import("react/jsx-runtime").JSX.Element | null;
-export interface FencyContext {
-    fency: FencyInstance;
-    loading: boolean;
-    error: Error | null;
-}
-/**
- * Props for FencyProvider
- */
-export interface FencyProviderProps {
-    fency: Promise<FencyInstance>;
-    children: React.ReactNode;
-}

package/lib/hooks/useFency.d.ts

@@ -1,5 +0,0 @@
-import type { FencyContext } from '../FencyProvider';
-/**
- * Hook to access Fency instance and loading state
- */
-export declare function useFency(): FencyContext;

package/lib/hooks/useFency.js

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