@fencyai/react 0.1.39 → 0.1.41

package/lib/index.d.ts

@@ -1,2 +1,5 @@
-export { useChatCompletions } from './chat-completions/useChatCompletions';
+export { useChatCompletions } from './useChatCompletions';
 export { FencyProvider, FencyProviderProps } from './provider/FencyProvider';
+export { CreateStreamingChatCompletionParams } from './useChatCompletions/useStreamingChatCompletions';
+export { CreateStructuredChatCompletionParams } from './useChatCompletions/useStructuredChatCompletions';
+export { CreateSynchronousChatCompletionParams } from './useChatCompletions/useSynchronousChatCompletions';

package/lib/index.js

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

package/lib/useChatCompletions/index.d.ts

@@ -0,0 +1,35 @@
+import { ApiError } from '@fencyai/js/lib/types/ApiError';
+import { ZodTypeAny } from 'zod';
+import { CreateStreamingChatCompletionParams, StreamingChatCompletion } from './useStreamingChatCompletions';
+import { CreateStructuredChatCompletionParams, StructuredChatCompletion, StructuredChatCompletionResponse } from './useStructuredChatCompletions';
+import { CreateSynchronousChatCompletionParams, SynchronousChatCompletion, SynchronousChatCompletionResponse } from './useSynchronousChatCompletions';
+type CombinedChatCompletion = {
+    type: 'synchronous';
+    chatCompletion: SynchronousChatCompletion;
+} | {
+    type: 'structured';
+    chatCompletion: StructuredChatCompletion<ZodTypeAny>;
+} | {
+    type: 'streaming';
+    chatCompletion: StreamingChatCompletion;
+};
+interface HookResponse {
+    latest: {
+        basic: SynchronousChatCompletion | null;
+        structured: StructuredChatCompletion<ZodTypeAny> | null;
+        streaming: StreamingChatCompletion | null;
+    };
+    chatCompletions: CombinedChatCompletion[];
+    createChatCompletion: (params: CreateSynchronousChatCompletionParams) => Promise<SynchronousChatCompletionResponse>;
+    createStructuredChatCompletion: <T extends ZodTypeAny>(params: CreateStructuredChatCompletionParams<T>) => Promise<StructuredChatCompletionResponse<T>>;
+    createStreamingChatCompletion: (params: CreateStreamingChatCompletionParams) => Promise<{
+        type: 'success';
+        chatCompletionStreamId: string;
+        chatCompletionId: string;
+    } | {
+        type: 'error';
+        error: ApiError;
+    }>;
+}
+export declare function useChatCompletions(): HookResponse;
+export {};

package/lib/useChatCompletions/index.js

@@ -0,0 +1,58 @@
+import { useMemo } from 'react';
+import { useFencyContext } from '../provider/useFencyContext';
+import { useStreamingChatCompletions, } from './useStreamingChatCompletions';
+import { useStructuredChatCompletions, } from './useStructuredChatCompletions';
+import { useSynchronousChatCompletions, } from './useSynchronousChatCompletions';
+export function useChatCompletions() {
+    const context = useFencyContext();
+    const synchronousChatCompletions = useSynchronousChatCompletions(context);
+    const streamingChatCompletions = useStreamingChatCompletions(context);
+    const structuredChatCompletions = useStructuredChatCompletions(context);
+    const combinedChatCompletions = useMemo(() => {
+        const completions = [];
+        for (const chatCompletion of synchronousChatCompletions.chatCompletions) {
+            completions.push({
+                type: 'synchronous',
+                chatCompletion: chatCompletion,
+            });
+        }
+        for (const chatCompletion of structuredChatCompletions.chatCompletions) {
+            completions.push({
+                type: 'structured',
+                chatCompletion: chatCompletion,
+            });
+        }
+        for (const chatCompletion of streamingChatCompletions.chatCompletions) {
+            completions.push({
+                type: 'streaming',
+                chatCompletion: chatCompletion,
+            });
+        }
+        return completions;
+    }, [
+        synchronousChatCompletions.chatCompletions,
+        structuredChatCompletions.chatCompletions,
+        streamingChatCompletions.chatCompletions,
+    ]);
+    const latest = useMemo(() => {
+        const lastCompletion = combinedChatCompletions[combinedChatCompletions.length - 1];
+        return {
+            basic: lastCompletion?.type === 'synchronous'
+                ? lastCompletion.chatCompletion
+                : null,
+            structured: lastCompletion?.type === 'structured'
+                ? lastCompletion.chatCompletion
+                : null,
+            streaming: lastCompletion?.type === 'streaming'
+                ? lastCompletion.chatCompletion
+                : null,
+        };
+    }, [combinedChatCompletions]);
+    return {
+        createChatCompletion: synchronousChatCompletions.createSynchronousChatCompletion,
+        createStructuredChatCompletion: structuredChatCompletions.createStructuredChatCompletion,
+        createStreamingChatCompletion: streamingChatCompletions.createStreamingChatCompletion,
+        chatCompletions: combinedChatCompletions,
+        latest,
+    };
+}

package/lib/useChatCompletions/types.d.ts

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

package/lib/useChatCompletions/types.js

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

package/lib/useChatCompletions/useStreamingChatCompletions.d.ts

@@ -0,0 +1,36 @@
+import { ChatCompletionStream } from '@fencyai/js';
+import { ApiError } from '@fencyai/js/lib/types/ApiError';
+import { FencyContext } from '../provider/FencyContext';
+import { ChatCompletionChunk } from '../useEventSource';
+import { CreateAnthropicChatCompletionParams, CreateGeminiChatCompletionParams, CreateOpenAiChatCompletionParams } from './types';
+export interface StreamingChatCompletionData {
+    id: string;
+    createdAt: string;
+    streamId: string;
+}
+export interface StreamingChatCompletion {
+    streamId: string;
+    data: StreamingChatCompletionData | null;
+    error: ApiError | null;
+    response: string;
+    chunks: ChatCompletionChunk[];
+    loading: boolean;
+    doneStreaming: boolean;
+}
+export interface CreateStreamingChatCompletionParams {
+    openai?: CreateOpenAiChatCompletionParams;
+    gemini?: CreateGeminiChatCompletionParams;
+    anthropic?: CreateAnthropicChatCompletionParams;
+}
+export declare const useStreamingChatCompletions: (context: FencyContext) => {
+    chatCompletions: StreamingChatCompletion[];
+    createStreamingChatCompletion: (params: CreateStreamingChatCompletionParams) => Promise<{
+        type: "success";
+        chatCompletionStreamId: string;
+        chatCompletionId: string;
+    } | {
+        type: "error";
+        error: ApiError;
+    }>;
+    stream: ChatCompletionStream | null;
+};

package/lib/useChatCompletions/useStreamingChatCompletions.js

@@ -0,0 +1,189 @@
+import { createChatCompletion, createChatCompletionStream, } from '@fencyai/js';
+import { useCallback, useEffect, useState } from 'react';
+import { useEventSource } from '../useEventSource';
+export const useStreamingChatCompletions = (context) => {
+    const [chatCompletions, setChatCompletions] = useState([]);
+    const [stream, setStream] = useState(null);
+    const [completedStreamIds, setCompletedStreamIds] = useState([]);
+    const [urlToStreamIdMapping, setUrlToStreamIdMapping] = useState({});
+    const { chunks, setUrl } = useEventSource({
+        onDone: (url) => {
+            const streamId = urlToStreamIdMapping[url];
+            if (!streamId) {
+                throw new Error(`Stream ID not found for URL: ${url}`);
+            }
+            setCompletedStreamIds((prev) => [...prev, streamId]);
+        },
+    });
+    useEffect(() => {
+        setChatCompletions((prev) => {
+            return prev.map((chatCompletion) => {
+                if (completedStreamIds.includes(chatCompletion.streamId)) {
+                    return {
+                        ...chatCompletion,
+                        doneStreaming: true,
+                        loading: false,
+                    };
+                }
+                return chatCompletion;
+            });
+        });
+    }, [completedStreamIds]);
+    useEffect(() => {
+        if (stream) {
+            const url = `${context.fency.baseUrl}/v1/pub/chat-completion-streams/${stream.id}?pk=${context.fency.publishableKey}`;
+            setUrl(url);
+            setUrlToStreamIdMapping((prev) => ({ ...prev, [url]: stream.id }));
+        }
+    }, [stream, context.fency.publishableKey, setUrl]);
+    useEffect(() => {
+        const newChatCompletions = [];
+        for (const chatCompletion of chatCompletions) {
+            const relevantChunks = chunks
+                .filter((chunk) => chunk.chatCompletionId === chatCompletion.data?.id)
+                .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+            const fullMessage = relevantChunks
+                .map((chunk) => chunk.content)
+                .join('');
+            newChatCompletions.push({
+                data: chatCompletion.data
+                    ? {
+                        id: chatCompletion.data.id,
+                        createdAt: chatCompletion.data.createdAt,
+                        streamId: chatCompletion.data.streamId,
+                    }
+                    : null,
+                streamId: chatCompletion.streamId,
+                error: chatCompletion.error,
+                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 createChatCompletionStream({
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
+        });
+        if (streamResponse.type === 'success') {
+            setStream(streamResponse.stream);
+            setChatCompletions([
+                ...chatCompletions,
+                {
+                    streamId: streamResponse.stream.id,
+                    data: null,
+                    error: null,
+                    response: '',
+                    chunks: [],
+                    loading: true,
+                    doneStreaming: false,
+                },
+            ]);
+            // 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,
+                },
+            });
+            if (chatCompletion.type === 'success' &&
+                chatCompletion.completion) {
+                const newCompletion = {
+                    triggeredAt: new Date().toISOString(),
+                    streamId: streamResponse.stream.id,
+                    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,
+                ]);
+                return {
+                    type: 'success',
+                    chatCompletionStreamId: streamResponse.stream.id,
+                    chatCompletionId: chatCompletion.completion.id,
+                };
+            }
+            else if (chatCompletion.type === 'error') {
+                setChatCompletions((prev) => [
+                    ...prev.filter((c) => c.streamId !== streamResponse.stream.id),
+                    {
+                        streamId: streamResponse.stream.id,
+                        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),
+                    {
+                        streamId: streamResponse.stream.id,
+                        error: error,
+                        response: '',
+                        chunks: [],
+                        loading: false,
+                        doneStreaming: false,
+                        data: null,
+                    },
+                ]);
+                return {
+                    type: 'error',
+                    error: error,
+                };
+            }
+        }
+        else {
+            console.error(streamResponse.error);
+            return streamResponse;
+        }
+    }, [context]);
+    return {
+        chatCompletions,
+        createStreamingChatCompletion,
+        stream,
+    };
+};

package/lib/useChatCompletions/useStructuredChatCompletions.d.ts

@@ -0,0 +1,32 @@
+import { ApiError } from '@fencyai/js/lib/types/ApiError';
+import { z, ZodTypeAny } from 'zod';
+import { FencyContext } from '../provider/FencyContext';
+import { CreateGeminiChatCompletionParams, CreateOpenAiChatCompletionParams } from './types';
+export interface StructuredChatCompletionData<T extends ZodTypeAny> {
+    id: string;
+    createdAt: string;
+    response: object;
+    structuredResponse: z.infer<T>;
+}
+export interface StructuredChatCompletion<T extends ZodTypeAny> {
+    triggeredAt: string;
+    data: StructuredChatCompletionData<T> | null;
+    error: ApiError | null;
+    loading: boolean;
+}
+export type StructuredChatCompletionResponse<T extends ZodTypeAny> = {
+    type: 'success';
+    data: StructuredChatCompletionData<T>;
+} | {
+    type: 'error';
+    error: ApiError;
+};
+export interface CreateStructuredChatCompletionParams<T extends ZodTypeAny> {
+    openai?: CreateOpenAiChatCompletionParams;
+    gemini?: CreateGeminiChatCompletionParams;
+    responseFormat: T;
+}
+export declare const useStructuredChatCompletions: (context: FencyContext) => {
+    chatCompletions: StructuredChatCompletion<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>[];
+    createStructuredChatCompletion: <T extends ZodTypeAny>(params: CreateStructuredChatCompletionParams<T>) => Promise<StructuredChatCompletionResponse<T>>;
+};

package/lib/useChatCompletions/useStructuredChatCompletions.js

@@ -0,0 +1,99 @@
+import { createChatCompletion } from '@fencyai/js';
+import { useCallback, useState } from 'react';
+import { z } from 'zod';
+export const useStructuredChatCompletions = (context) => {
+    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 parsedJsonSchema = JSON.stringify(jsonSchema);
+        const response = await createChatCompletion({
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
+            request: {
+                openai: params.openai
+                    ? {
+                        model: params.openai.model,
+                        responseJsonSchema: parsedJsonSchema,
+                        messages: params.openai.messages,
+                    }
+                    : undefined,
+                gemini: params.gemini
+                    ? {
+                        model: params.gemini.model,
+                        responseJsonSchema: parsedJsonSchema,
+                        content: params.gemini.content,
+                    }
+                    : undefined,
+            },
+        });
+        if (response.type === 'success') {
+            if (response.completion.response) {
+                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)),
+                };
+                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]);
+    return {
+        chatCompletions,
+        createStructuredChatCompletion,
+    };
+};

package/lib/useChatCompletions/useSynchronousChatCompletions.d.ts

@@ -0,0 +1,30 @@
+import { ApiError } from '@fencyai/js/lib/types/ApiError';
+import { FencyContext } from '../provider/FencyContext';
+import { CreateAnthropicChatCompletionParams, CreateGeminiChatCompletionParams, CreateOpenAiChatCompletionParams } from './types';
+export interface SynchronousChatCompletionData {
+    id: string;
+    createdAt: string;
+    response: string;
+}
+export interface SynchronousChatCompletion {
+    triggeredAt: string;
+    data: SynchronousChatCompletionData | null;
+    error: ApiError | null;
+    loading: boolean;
+}
+export type SynchronousChatCompletionResponse = {
+    type: 'success';
+    data: SynchronousChatCompletionData;
+} | {
+    type: 'error';
+    error: ApiError;
+};
+export interface CreateSynchronousChatCompletionParams {
+    openai?: CreateOpenAiChatCompletionParams;
+    gemini?: CreateGeminiChatCompletionParams;
+    anthropic?: CreateAnthropicChatCompletionParams;
+}
+export declare const useSynchronousChatCompletions: (context: FencyContext) => {
+    chatCompletions: SynchronousChatCompletion[];
+    createSynchronousChatCompletion: (params: CreateSynchronousChatCompletionParams) => Promise<SynchronousChatCompletionResponse>;
+};

package/lib/useChatCompletions/useSynchronousChatCompletions.js

@@ -0,0 +1,106 @@
+import { createChatCompletion } from '@fencyai/js';
+import { useCallback, useState } from 'react';
+export const useSynchronousChatCompletions = (context) => {
+    const [chatCompletions, setChatCompletions] = useState([]);
+    const createSynchronousChatCompletion = useCallback(async (params) => {
+        const triggeredAt = new Date().toISOString();
+        setChatCompletions((prev) => [
+            ...prev,
+            {
+                triggeredAt,
+                data: null,
+                error: null,
+                loading: true,
+            },
+        ]);
+        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,
+            },
+        });
+        if (chatCompletion.type === 'success' &&
+            chatCompletion.completion.response) {
+            const updatedCompletion = {
+                triggeredAt,
+                data: {
+                    id: chatCompletion.completion.id,
+                    createdAt: chatCompletion.completion.createdAt,
+                    response: chatCompletion.completion.response,
+                },
+                error: null,
+                loading: false,
+            };
+            setChatCompletions((prev) => [
+                ...prev.filter((c) => c.triggeredAt !== triggeredAt),
+                updatedCompletion,
+            ]);
+            return {
+                type: 'success',
+                data: updatedCompletion.data,
+            };
+        }
+        else if (chatCompletion.type === 'error') {
+            const errorCompletion = {
+                triggeredAt,
+                data: null,
+                error: chatCompletion.error,
+                loading: false,
+            };
+            setChatCompletions((prev) => [...prev, errorCompletion]);
+            return {
+                type: 'error',
+                error: chatCompletion.error,
+            };
+        }
+        else {
+            const error = {
+                message: 'No response received',
+                code: 'UnknownError',
+            };
+            setChatCompletions((prev) => [
+                ...prev.filter((c) => c.triggeredAt !== triggeredAt),
+                {
+                    triggeredAt,
+                    data: null,
+                    error: error,
+                    loading: false,
+                },
+            ]);
+            return {
+                type: 'error',
+                error: error,
+            };
+        }
+    }, [context]);
+    return {
+        chatCompletions,
+        createSynchronousChatCompletion,
+    };
+};

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

@@ -1,4 +1,6 @@
-export declare function useEventSource(): {
+export declare function useEventSource(props?: {
+    onDone?: (url: string) => void;
+}): {
     chunks: ChatCompletionChunk[];
     setUrl: import("react").Dispatch<import("react").SetStateAction<string | null | undefined>>;
     url: string | null | undefined;

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

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-export function useEventSource() {
+export function useEventSource(props) {
     const [chunks, setChunks] = useState([]);
     const [url, setUrl] = useState();
     useEffect(() => {
@@ -10,6 +10,7 @@ export function useEventSource() {
             if (message.data === '__END_OF_STREAM__') {
                 eventSource.close();
                 setUrl(null); // Clear URL to prevent reconnection
+                props?.onDone?.(url);
                 return;
             }
             const chunk = getChatCompletionChunk(message);
@@ -35,9 +36,17 @@ export function useEventSource() {
         url,
     };
 }
-const base64Decode = (str) => {
-    return atob(str);
-};
+function base64Decode(base64) {
+    // Decode Base64 -> binary string
+    const binary = atob(base64);
+    // Convert binary string -> Uint8Array
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    // Decode UTF-8 bytes -> proper string
+    return new TextDecoder('utf-8').decode(bytes);
+}
 const getChatCompletionChunk = (message) => {
     try {
         const json = JSON.parse(base64Decode(message.data));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fencyai/react",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "> TODO: description",
   "author": "staklau <steinaageklaussen@gmail.com>",
   "homepage": "",
@@ -36,7 +36,7 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@fencyai/js": "^0.1.39",
+    "@fencyai/js": "^0.1.41",
     "@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.39",
+    "@fencyai/js": "^0.1.41",
     "react": ">=16.8.0"
   },
-  "gitHead": "799ae72310f87de040cd45875f4a718df1807764"
+  "gitHead": "cfe3e77d5266d35c1d39674bdcd2cb1888789b60"
 }

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

@@ -1,53 +0,0 @@
-import { ChatCompletion, CreateAnthropicChatCompletionParams, CreateGeminiChatCompletionParams, CreateOpenAiChatCompletionParams } from '@fencyai/js';
-import { ApiError } from '@fencyai/js/lib/types/ApiError';
-import z, { ZodTypeAny } from 'zod';
-import { ChatCompletionChunk } from './useEventSource';
-interface Completions {
-    chatCompletion: ChatCompletion & {
-        structuredResponse?: any;
-    };
-    chunks: ChatCompletionChunk[];
-    response: string;
-}
-interface HookResponse {
-    chatCompletions: Completions[];
-    createChatCompletion: (params: {
-        openai?: CreateOpenAiChatCompletionParams;
-        anthropic?: CreateAnthropicChatCompletionParams;
-        gemini?: CreateGeminiChatCompletionParams;
-    }) => Promise<{
-        type: 'success';
-        chatCompletion: ChatCompletion;
-    } | {
-        type: 'error';
-        error: ApiError;
-    }>;
-    createStructuredChatCompletion: <T extends ZodTypeAny>(params: {
-        openai?: CreateOpenAiChatCompletionParams;
-        gemini?: CreateGeminiChatCompletionParams;
-        responseFormat: T;
-    }) => Promise<{
-        type: 'success';
-        chatCompletion: ChatCompletion & {
-            structuredResponse: z.infer<T>;
-        };
-    } | {
-        type: 'error';
-        error: ApiError;
-    }>;
-    createStreamingChatCompletion: (params: {
-        openai?: CreateOpenAiChatCompletionParams;
-        anthropic?: CreateAnthropicChatCompletionParams;
-        gemini?: CreateGeminiChatCompletionParams;
-    }) => Promise<{
-        type: 'success';
-        chatCompletionStreamId: string;
-        chatCompletionId: string;
-    } | {
-        type: 'error';
-        error: ApiError;
-    }>;
-    latest: Completions | null;
-}
-export declare function useChatCompletions(): HookResponse;
-export {};

package/lib/chat-completions/useChatCompletions.js

@@ -1,192 +0,0 @@
-// hooks/useChatCompletion.ts
-import { createChatCompletion, createChatCompletionStream, } from '@fencyai/js';
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import z from 'zod';
-import { useFencyContext } from '../provider/useFencyContext';
-import { useEventSource } from './useEventSource';
-export function useChatCompletions() {
-    const context = useFencyContext();
-    const { chunks, setUrl } = useEventSource();
-    const [chatCompletions, setChatCompletions] = useState([]);
-    const [stream, setStream] = useState(null);
-    const createStreamingChatCompletion = useCallback(async (params) => {
-        // Step 1: Create stream if not exists
-        const streamResponse = await createChatCompletionStream({
-            pk: context.fency.publishableKey,
-            baseUrl: context.fency.baseUrl,
-        });
-        if (streamResponse.type === 'success') {
-            setStream(streamResponse.stream);
-            // 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,
-                },
-            });
-            if (chatCompletion.type === 'success') {
-                setChatCompletions((prev) => [
-                    ...prev,
-                    chatCompletion.completion,
-                ]);
-                return {
-                    type: 'success',
-                    chatCompletionStreamId: streamResponse.stream.id,
-                    chatCompletionId: chatCompletion.completion.id,
-                };
-            }
-            else {
-                return chatCompletion;
-            }
-        }
-        else {
-            return streamResponse;
-        }
-    }, [context]);
-    const createSynchronousChatCompletion = useCallback(async (params) => {
-        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,
-            },
-        });
-        if (chatCompletion.type === 'success') {
-            setChatCompletions((prev) => [
-                ...prev,
-                chatCompletion.completion,
-            ]);
-            return {
-                type: 'success',
-                chatCompletion: chatCompletion.completion,
-            };
-        }
-        else {
-            return chatCompletion;
-        }
-    }, [context]);
-    const createStructuredChatCompletion = useCallback(async (params) => {
-        const jsonSchema = z.toJSONSchema(params.responseFormat);
-        const parsedJsonSchema = JSON.stringify(jsonSchema);
-        const response = await createChatCompletion({
-            pk: context.fency.publishableKey,
-            baseUrl: context.fency.baseUrl,
-            request: {
-                openai: params.openai
-                    ? {
-                        model: params.openai.model,
-                        responseJsonSchema: parsedJsonSchema,
-                        messages: params.openai.messages,
-                    }
-                    : undefined,
-                gemini: params.gemini
-                    ? {
-                        model: params.gemini.model,
-                        responseJsonSchema: parsedJsonSchema,
-                        content: params.gemini.content,
-                    }
-                    : undefined,
-            },
-        });
-        if (response.type === 'success') {
-            setChatCompletions((prev) => [...prev, response.completion]);
-            if (response.completion.response) {
-                return {
-                    type: 'success',
-                    chatCompletion: {
-                        ...response.completion,
-                        structuredResponse: params.responseFormat.parse(JSON.parse(response.completion.response)),
-                    },
-                };
-            }
-            else {
-                return {
-                    type: 'error',
-                    error: {
-                        code: 'NoResponse',
-                        message: 'No response from chat completion',
-                    },
-                };
-            }
-        }
-        else {
-            return response;
-        }
-    }, [context]);
-    const completions = useMemo(() => {
-        const completions = [];
-        for (const chatCompletion of chatCompletions) {
-            const relevantChunks = chunks
-                .filter((chunk) => chunk.chatCompletionId === chatCompletion.id)
-                .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-            const fullMessage = relevantChunks
-                .map((chunk) => chunk.content)
-                .join('');
-            completions.push({
-                chatCompletion,
-                chunks: relevantChunks,
-                response: fullMessage,
-            });
-        }
-        return completions;
-    }, [chunks, chatCompletions]);
-    const latest = useMemo(() => {
-        return completions[completions.length - 1];
-    }, [completions]);
-    useEffect(() => {
-        if (stream) {
-            setUrl(`${context.fency.baseUrl}/v1/pub/chat-completion-streams/${stream.id}?pk=${context.fency.publishableKey}`);
-        }
-    }, [stream, context.fency.publishableKey, setUrl]);
-    return {
-        createChatCompletion: createSynchronousChatCompletion,
-        createStructuredChatCompletion: createStructuredChatCompletion,
-        createStreamingChatCompletion: createStreamingChatCompletion,
-        chatCompletions: completions,
-        latest,
-    };
-}