@fencyai/react 0.1.52 → 0.1.54

package/lib/hooks/useBasicChatCompletions/index.js

@@ -1,6 +1,7 @@
 import { createChatCompletion } from '@fencyai/js';
 import { useCallback, useMemo, useState } from 'react';
 import { useFencyContext } from '../../provider/useFencyContext';
+import { toSpecificChatCompletionParams } from '../../types/CreateGenericChatCompletionParams';
 export const useBasicChatCompletions = () => {
     const context = useFencyContext();
     const [chatCompletions, setChatCompletions] = useState([]);
@@ -15,36 +16,12 @@ export const useBasicChatCompletions = () => {
                 loading: true,
             },
         ]);
+        const specificParams = toSpecificChatCompletionParams(params.openai, params.gemini, params.claude, params.generic);
         const chatCompletion = await createChatCompletion({
             pk: context.fency.publishableKey,
             baseUrl: context.fency.baseUrl,
             request: {
-                openai: params.openai
-                    ? {
-                        model: params.openai.model,
-                        messages: params.openai.messages,
-                        temperature: params.openai.temperature,
-                        topP: params.openai.topP,
-                    }
-                    : undefined,
-                gemini: params.gemini
-                    ? {
-                        model: params.gemini.model,
-                        content: params.gemini.content,
-                        temperature: params.gemini.temperature,
-                        topP: params.gemini.topP,
-                        topK: params.gemini.topK,
-                    }
-                    : undefined,
-                anthropic: params.anthropic
-                    ? {
-                        model: params.anthropic.model,
-                        messages: params.anthropic.messages,
-                        temperature: params.anthropic.temperature,
-                        topP: params.anthropic.topP,
-                        topK: params.anthropic.topK,
-                    }
-                    : undefined,
+                ...specificParams,
             },
         });
         if (chatCompletion.type === 'success' &&
@@ -103,7 +80,8 @@ export const useBasicChatCompletions = () => {
     }, [context]);
     const latest = useMemo(() => {
         return chatCompletions.sort((a, b) => {
-            return new Date(b.triggeredAt).getTime() - new Date(a.triggeredAt).getTime();
+            return (new Date(b.triggeredAt).getTime() -
+                new Date(a.triggeredAt).getTime());
         })[0];
     }, [chatCompletions]);
     return {

package/lib/hooks/useStreamingChatCompletions/index.js

@@ -1,13 +1,14 @@
 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 = () => {
     const context = useFencyContext();
     const [chatCompletions, setChatCompletions] = useState([]);
     const [completedStreamIds, setCompletedStreamIds] = useState([]);
     const [chunks, setChunks] = useState([]);
-    const { stream, createStream } = useStream({
+    const { createStream } = useStream({
         onNewChatCompletionStreamChunk: (streamData) => {
             setChunks((prev) => [...prev, streamData]);
         },
@@ -66,6 +67,7 @@ export const useStreamingChatCompletions = () => {
                     : null,
                 streamId: chatCompletion.streamId,
                 error: chatCompletion.error,
+                prompt: chatCompletion.prompt,
                 loading: chatCompletion.loading,
                 doneStreaming: chatCompletion.doneStreaming,
                 response: fullMessage,
@@ -87,57 +89,42 @@ export const useStreamingChatCompletions = () => {
                     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,
-                    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,
+                    ...specificParams,
                 },
             });
             if (chatCompletion.type === 'success' &&
                 chatCompletion.completion) {
-                const newCompletion = {
-                    streamId: streamResponse.stream.id,
-                    triggeredAt: new Date().toISOString(),
-                    data: {
-                        id: chatCompletion.completion.id,
-                        createdAt: chatCompletion.completion.createdAt,
-                        streamId: streamResponse.stream.id,
-                    },
-                    error: null,
-                    response: '',
-                    chunks: [],
-                    doneStreaming: false,
-                    loading: true,
-                };
                 setChatCompletions((prev) => [
                     ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
-                    newCompletion,
+                    {
+                        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',
@@ -151,6 +138,7 @@ export const useStreamingChatCompletions = () => {
                     {
                         triggeredAt: new Date().toISOString(),
                         streamId: streamResponse.stream.id,
+                        prompt: params,
                         error: chatCompletion.error,
                         response: '',
                         chunks: [],
@@ -175,6 +163,7 @@ export const useStreamingChatCompletions = () => {
                         triggeredAt: new Date().toISOString(),
                         streamId: streamResponse.stream.id,
                         error: error,
+                        prompt: params,
                         response: '',
                         chunks: [],
                         loading: false,
@@ -192,7 +181,7 @@ export const useStreamingChatCompletions = () => {
             console.error(streamResponse.error);
             return streamResponse;
         }
-    }, [context]);
+    }, [context, chatCompletions]);
     const latest = useMemo(() => {
         return chatCompletions.sort((a, b) => {
             return (new Date(b.triggeredAt).getTime() -

package/lib/hooks/useStructuredChatCompletions/index.js

@@ -2,6 +2,7 @@ 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([]);
@@ -28,22 +29,26 @@ export const useStructuredChatCompletions = () => {
             }
         };
         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: params.openai
+                openai: specificParams.openai
                     ? {
-                        model: params.openai.model,
                         responseJsonSchema: parsedJsonSchema,
-                        messages: params.openai.messages,
+                        ...specificParams.openai,
                     }
                     : undefined,
-                gemini: params.gemini
+                gemini: specificParams.gemini
                     ? {
-                        model: params.gemini.model,
                         responseJsonSchema: parsedJsonSchema,
-                        content: params.gemini.content,
+                        ...specificParams.gemini,
+                    }
+                    : undefined,
+                claude: specificParams.claude
+                    ? {
+                        ...specificParams.claude,
                     }
                     : undefined,
             },

package/lib/types/AiModel.d.ts

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

package/lib/types/CreateBasicChatCompletionParams.d.ts

@@ -1,8 +1,10 @@
-import { CreateOpenAiChatCompletionParams } from './CreateOpenAiChatCompletionParams';
+import { CreateClaudeChatCompletionParams } from './CreateClaudeChatCompletionParams';
 import { CreateGeminiChatCompletionParams } from './CreateGeminiChatCompletionParams';
-import { CreateAnthropicChatCompletionParams } from './CreateAnthropicChatCompletionParams';
+import { CreateOpenAiChatCompletionParams } from './CreateOpenAiChatCompletionParams';
+import { CreateGenericChatCompletionParams } from './CreateGenericChatCompletionParams';
 export interface CreateBasicChatCompletionParams {
     openai?: CreateOpenAiChatCompletionParams;
     gemini?: CreateGeminiChatCompletionParams;
-    anthropic?: CreateAnthropicChatCompletionParams;
+    claude?: CreateClaudeChatCompletionParams;
+    generic?: CreateGenericChatCompletionParams;
 }

package/lib/types/CreateClaudeChatCompletionParams.d.ts

@@ -0,0 +1,9 @@
+import { AnthropicModel, ClaudeChatCompletionMessage } from '@fencyai/js';
+export interface CreateClaudeChatCompletionParams {
+    model: AnthropicModel;
+    messages: Array<ClaudeChatCompletionMessage>;
+    systemPrompt?: string;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}

package/lib/types/CreateClaudeChatCompletionParams.js

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

package/lib/types/CreateGeminiChatCompletionParams.d.ts

@@ -1,7 +1,9 @@
-import { GeminiModel } from '@fencyai/js/lib/types/GeminiModel';
+import { GeminiModel } from '@fencyai/js';
+import { GeminiChatCompletionMessage } from '@fencyai/js';
 export interface CreateGeminiChatCompletionParams {
     model: GeminiModel;
-    content: string;
+    messages: Array<GeminiChatCompletionMessage>;
+    systemPrompt?: string;
     temperature?: number;
     topP?: number;
     topK?: number;

package/lib/types/CreateGenericChatCompletionParams.d.ts

@@ -0,0 +1,14 @@
+import { ChatCompletionMessage, CreateClaudeChatCompletionRequestParams, CreateGeminiChatCompletionRequestParams, CreateOpenAiChatCompletionRequestParams } from '@fencyai/js';
+import { AiModel } from './AiModel';
+export interface CreateGenericChatCompletionParams {
+    model: AiModel;
+    messages: Array<ChatCompletionMessage>;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}
+export declare const toSpecificChatCompletionParams: (openai?: CreateOpenAiChatCompletionRequestParams, gemini?: CreateGeminiChatCompletionRequestParams, claude?: CreateClaudeChatCompletionRequestParams, generic?: CreateGenericChatCompletionParams) => {
+    openai?: CreateOpenAiChatCompletionRequestParams;
+    gemini?: CreateGeminiChatCompletionRequestParams;
+    claude?: CreateClaudeChatCompletionRequestParams;
+};

package/lib/types/CreateGenericChatCompletionParams.js

@@ -0,0 +1,169 @@
+export const toSpecificChatCompletionParams = (openai, gemini, claude, generic) => {
+    if (openai) {
+        return {
+            openai,
+        };
+    }
+    if (gemini) {
+        return {
+            gemini,
+        };
+    }
+    if (claude) {
+        return {
+            claude,
+        };
+    }
+    if (generic) {
+        if (isOpenAiModel(generic.model)) {
+            return {
+                openai: {
+                    model: generic.model,
+                    messages: generic.messages,
+                    temperature: generic.temperature,
+                    topP: generic.topP,
+                },
+            };
+        }
+        if (isGeminiModel(generic.model)) {
+            return {
+                gemini: {
+                    model: generic.model,
+                    messages: toGeminiChatCompletionMessages(generic.messages),
+                    systemPrompt: getSystemPromptFromMessages(generic.messages),
+                    temperature: generic.temperature,
+                    topP: generic.topP,
+                    topK: generic.topK,
+                },
+            };
+        }
+        if (isAnthropicModel(generic.model)) {
+            return {
+                claude: {
+                    model: generic.model,
+                    messages: toClaudeChatCompletionMessages(generic.messages),
+                    systemPrompt: getSystemPromptFromMessages(generic.messages),
+                    temperature: generic.temperature,
+                    topP: generic.topP,
+                    topK: generic.topK,
+                },
+            };
+        }
+    }
+    throw new Error('No model provided');
+};
+const getSystemPromptFromMessages = (messages) => {
+    const allSystemPrompts = messages
+        .filter((message) => message.role === 'system')
+        .map((message) => message.content);
+    return allSystemPrompts.join('\n');
+};
+const toGeminiChatCompletionMessages = (messages) => {
+    const convertedMessages = messages.flatMap((message) => {
+        if (message.role === 'system') {
+            return [];
+        }
+        if (message.role === 'user') {
+            return [{ role: 'user', content: message.content }];
+        }
+        if (message.role === 'assistant') {
+            return [{ role: 'model', content: message.content }];
+        }
+        return [];
+    });
+    return convertedMessages;
+};
+const toClaudeChatCompletionMessages = (messages) => {
+    const convertedMessages = messages.flatMap((message) => {
+        if (message.role === 'system') {
+            return [];
+        }
+        if (message.role === 'user') {
+            return [{ role: 'user', content: message.content }];
+        }
+        if (message.role === 'assistant') {
+            return [{ role: 'assistant', content: message.content }];
+        }
+        return [];
+    });
+    return convertedMessages;
+};
+const isOpenAiModel = (model) => {
+    switch (model) {
+        // OpenAI models
+        case 'gpt-4.1':
+            return true;
+        case 'gpt-4.1-mini':
+            return true;
+        case 'gpt-4.1-nano':
+            return true;
+        case 'gpt-4o':
+            return true;
+        case 'gpt-4o-mini':
+            return true;
+        // Gemini models
+        case 'gemini-2.5-pro':
+            return true;
+        case 'gemini-2.5-flash':
+            return true;
+        case 'gemini-2.5-flash-lite-preview-06-17':
+            return true;
+        // Claude models
+        case 'claude-opus-4-0':
+            return true;
+        case 'claude-sonnet-4-0':
+            return true;
+    }
+};
+const isGeminiModel = (model) => {
+    switch (model) {
+        case 'gpt-4.1':
+            return false;
+        case 'gpt-4.1-mini':
+            return false;
+        case 'gpt-4.1-nano':
+            return false;
+        case 'gpt-4o':
+            return false;
+        case 'gpt-4o-mini':
+            return false;
+        // Gemini models
+        case 'gemini-2.5-pro':
+            return true;
+        case 'gemini-2.5-flash':
+            return true;
+        case 'gemini-2.5-flash-lite-preview-06-17':
+            return true;
+        // Claude models
+        case 'claude-opus-4-0':
+            return false;
+        case 'claude-sonnet-4-0':
+            return false;
+    }
+};
+const isAnthropicModel = (model) => {
+    switch (model) {
+        case 'gpt-4.1':
+            return false;
+        case 'gpt-4.1-mini':
+            return false;
+        case 'gpt-4.1-nano':
+            return false;
+        case 'gpt-4o':
+            return false;
+        case 'gpt-4o-mini':
+            return false;
+        // Gemini models
+        case 'gemini-2.5-pro':
+            return false;
+        case 'gemini-2.5-flash':
+            return false;
+        case 'gemini-2.5-flash-lite-preview-06-17':
+            return false;
+        // Claude models
+        case 'claude-opus-4-0':
+            return true;
+        case 'claude-sonnet-4-0':
+            return true;
+    }
+};

package/lib/types/CreateOpenAiChatCompletionParams.d.ts

@@ -1,5 +1,5 @@
-import { OpenAiModel } from '@fencyai/js/lib/types/OpenAiModel';
-import { ChatCompletionMessage } from '@fencyai/js/lib/types/ChatCompletionMessage';
+import { OpenAiModel } from '@fencyai/js';
+import { ChatCompletionMessage } from '@fencyai/js';
 export interface CreateOpenAiChatCompletionParams {
     model: OpenAiModel;
     messages: Array<ChatCompletionMessage>;

package/lib/types/CreateStreamingChatCompletionParams.d.ts

@@ -1,8 +1,10 @@
 import { CreateOpenAiChatCompletionParams } from './CreateOpenAiChatCompletionParams';
 import { CreateGeminiChatCompletionParams } from './CreateGeminiChatCompletionParams';
-import { CreateAnthropicChatCompletionParams } from './CreateAnthropicChatCompletionParams';
+import { CreateClaudeChatCompletionParams } from './CreateClaudeChatCompletionParams';
+import { CreateGenericChatCompletionParams } from './CreateGenericChatCompletionParams';
 export interface CreateStreamingChatCompletionParams {
     openai?: CreateOpenAiChatCompletionParams;
     gemini?: CreateGeminiChatCompletionParams;
-    anthropic?: CreateAnthropicChatCompletionParams;
+    claude?: CreateClaudeChatCompletionParams;
+    generic?: CreateGenericChatCompletionParams;
 }

package/lib/types/CreateStructuredChatCompletionParams.d.ts

@@ -1,8 +1,12 @@
 import { ZodTypeAny } from 'zod';
 import { CreateOpenAiChatCompletionParams } from './CreateOpenAiChatCompletionParams';
 import { CreateGeminiChatCompletionParams } from './CreateGeminiChatCompletionParams';
+import { CreateClaudeChatCompletionParams } from './CreateClaudeChatCompletionParams';
+import { CreateGenericChatCompletionParams } from './CreateGenericChatCompletionParams';
 export interface CreateStructuredChatCompletionParams<T extends ZodTypeAny> {
     openai?: CreateOpenAiChatCompletionParams;
     gemini?: CreateGeminiChatCompletionParams;
+    claude?: CreateClaudeChatCompletionParams;
+    generic?: CreateGenericChatCompletionParams;
     responseFormat: T;
 }

package/lib/types/StreamingChatCompletion.d.ts

@@ -1,9 +1,19 @@
 import { ApiError } from '@fencyai/js';
-import { StreamingChatCompletionData } from './StreamingChatCompletionData';
+import { CreateClaudeChatCompletionParams } from './CreateClaudeChatCompletionParams';
+import { CreateGenericChatCompletionParams } from './CreateGenericChatCompletionParams';
+import { CreateGeminiChatCompletionParams } from './CreateGeminiChatCompletionParams';
+import { CreateOpenAiChatCompletionParams } from './CreateOpenAiChatCompletionParams';
 import { NewChatCompletionStreamChunk } from './StreamData';
+import { StreamingChatCompletionData } from './StreamingChatCompletionData';
 export interface StreamingChatCompletion {
     triggeredAt: string;
     streamId: string;
+    prompt: {
+        openai?: CreateOpenAiChatCompletionParams;
+        gemini?: CreateGeminiChatCompletionParams;
+        claude?: CreateClaudeChatCompletionParams;
+        generic?: CreateGenericChatCompletionParams;
+    };
     data: StreamingChatCompletionData | null;
     error: ApiError | null;
     response: string;

package/lib/types/index.d.ts

@@ -2,7 +2,7 @@ export * from './FencyProviderProps';
 export * from './FencyContext';
 export * from './CreateOpenAiChatCompletionParams';
 export * from './CreateGeminiChatCompletionParams';
-export * from './CreateAnthropicChatCompletionParams';
+export * from './CreateClaudeChatCompletionParams';
 export * from './BasicChatCompletionData';
 export * from './BasicChatCompletion';
 export * from './BasicChatCompletionResponse';

package/lib/types/index.js

@@ -4,7 +4,7 @@ export * from './FencyContext';
 // Chat completion parameter types
 export * from './CreateOpenAiChatCompletionParams';
 export * from './CreateGeminiChatCompletionParams';
-export * from './CreateAnthropicChatCompletionParams';
+export * from './CreateClaudeChatCompletionParams';
 // Basic chat completion types
 export * from './BasicChatCompletionData';
 export * from './BasicChatCompletion';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fencyai/react",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "> TODO: description",
   "author": "staklau <steinaageklaussen@gmail.com>",
   "homepage": "",
@@ -32,11 +32,8 @@
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build"
   },
-  "dependencies": {
-    "zod": "^4.0.5"
-  },
   "devDependencies": {
-    "@fencyai/js": "^0.1.52",
+    "@fencyai/js": "^0.1.54",
     "@types/jest": "^29.5.11",
     "@types/node": "^20.10.5",
     "@types/react": "^18.2.45",
@@ -45,8 +42,14 @@
     "typescript": "^5.3.3"
   },
   "peerDependencies": {
-    "@fencyai/js": "^0.1.52",
-    "react": ">=16.8.0"
+    "@fencyai/js": "^0.1.54",
+    "react": ">=16.8.0",
+    "zod": "^4.0.5"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": false
+    }
   },
-  "gitHead": "e2f699d585862ff1fd0725355f5e3f4d2ed48284"
+  "gitHead": "42e5ede5f912c388e8ba5bd37e0d04a539771d8e"
 }

package/lib/types/CreateAnthropicChatCompletionParams.d.ts

@@ -1,9 +0,0 @@
-import { AnthropicModel } from '@fencyai/js/lib/types/AnthropicModel';
-import { ChatCompletionMessage } from '@fencyai/js/lib/types/ChatCompletionMessage';
-export interface CreateAnthropicChatCompletionParams {
-    model: AnthropicModel;
-    messages: Array<ChatCompletionMessage>;
-    temperature?: number;
-    topP?: number;
-    topK?: number;
-}