@fencyai/react 0.1.42 → 0.1.43

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 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';
+export { useFileUploads } from './useFileUploads';
+export { useWebsites } from './useWebsites';
+export { FencyProvider } from './provider/FencyProvider';
+export * from './types';

package/lib/index.js

@@ -1,4 +1,8 @@
 // Re-export components and hooks
 export { useChatCompletions } from './useChatCompletions';
-// Re-export types
+export { useFileUploads } from './useFileUploads';
+export { useWebsites } from './useWebsites';
+// Re-export providers
 export { FencyProvider } from './provider/FencyProvider';
+// Re-export all types from centralized location
+export * from './types';

package/lib/provider/FencyContextValue.d.ts

@@ -0,0 +1,2 @@
+import { FencyContext } from '../types/FencyContext';
+export declare const FencyContextValue: import("react").Context<FencyContext | undefined>;

package/lib/provider/FencyProvider.d.ts

@@ -1,9 +1,2 @@
-import { FencyInstance } from '@fencyai/js';
-export interface FencyProviderProps {
-    fency: Promise<FencyInstance>;
-    children: React.ReactNode;
-    options?: {
-        fetchClientSecret: () => Promise<string>;
-    };
-}
+import { FencyProviderProps } from '../types/FencyProviderProps';
 export declare function FencyProvider({ fency, children }: FencyProviderProps): import("react/jsx-runtime").JSX.Element | null;

package/lib/provider/FencyProvider.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { FencyContextValue } from './FencyContext';
+import { FencyContextValue } from './FencyContextValue';
 export function FencyProvider({ fency, children }) {
     const [fencyInstance, setFencyInstance] = useState(null);
     const [loading, setLoading] = useState(true);

package/lib/provider/useFencyContext.d.ts

@@ -1,4 +1,4 @@
-import type { FencyContext } from './FencyContext';
+import type { FencyContext } from '../types/FencyContext';
 /**
  * Hook to access Fency instance and loading state
  */

package/lib/provider/useFencyContext.js

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
-import { FencyContextValue } from './FencyContext';
+import { FencyContextValue } from './FencyContextValue';
 /**
  * Hook to access Fency instance and loading state
  */

package/lib/types/CombinedChatCompletion.d.ts

@@ -0,0 +1,14 @@
+import { ZodTypeAny } from 'zod';
+import { SynchronousChatCompletion } from './SynchronousChatCompletion';
+import { StructuredChatCompletion } from './StructuredChatCompletion';
+import { StreamingChatCompletion } from './StreamingChatCompletion';
+export type CombinedChatCompletion = {
+    type: 'synchronous';
+    chatCompletion: SynchronousChatCompletion;
+} | {
+    type: 'structured';
+    chatCompletion: StructuredChatCompletion<ZodTypeAny>;
+} | {
+    type: 'streaming';
+    chatCompletion: StreamingChatCompletion;
+};

package/lib/types/CreateAnthropicChatCompletionParams.d.ts

@@ -0,0 +1,9 @@
+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;
+}

package/lib/types/CreateAnthropicChatCompletionParams.js

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

package/lib/types/CreateGeminiChatCompletionParams.d.ts

@@ -0,0 +1,8 @@
+import { GeminiModel } from '@fencyai/js/lib/types/GeminiModel';
+export interface CreateGeminiChatCompletionParams {
+    model: GeminiModel;
+    content: string;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}

package/lib/types/CreateGeminiChatCompletionParams.js

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

package/lib/types/CreateOpenAiChatCompletionParams.d.ts

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

package/lib/types/CreateOpenAiChatCompletionParams.js

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

package/lib/types/CreateStreamResponse.d.ts

@@ -0,0 +1,8 @@
+import { ApiError, Stream } from '@fencyai/js';
+export type CreateStreamResponse = {
+    type: 'success';
+    stream: Stream;
+} | {
+    type: 'error';
+    error: ApiError;
+};

package/lib/types/CreateStreamResponse.js

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

package/lib/types/CreateStreamingChatCompletionParams.d.ts

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

package/lib/types/CreateStreamingChatCompletionParams.js

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

package/lib/types/CreateStructuredChatCompletionParams.d.ts

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

package/lib/types/CreateStructuredChatCompletionParams.js

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

package/lib/types/CreateSynchronousChatCompletionParams.d.ts

@@ -0,0 +1,8 @@
+import { CreateOpenAiChatCompletionParams } from './CreateOpenAiChatCompletionParams';
+import { CreateGeminiChatCompletionParams } from './CreateGeminiChatCompletionParams';
+import { CreateAnthropicChatCompletionParams } from './CreateAnthropicChatCompletionParams';
+export interface CreateSynchronousChatCompletionParams {
+    openai?: CreateOpenAiChatCompletionParams;
+    gemini?: CreateGeminiChatCompletionParams;
+    anthropic?: CreateAnthropicChatCompletionParams;
+}

package/lib/types/CreateSynchronousChatCompletionParams.js

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

package/lib/types/CreateUploadParams.d.ts

@@ -0,0 +1,5 @@
+export interface CreateUploadParams {
+    fileName: string;
+    fileType: string;
+    fileSize: number;
+}

package/lib/types/CreateUploadParams.js

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

package/lib/types/CreateWebsiteParams.d.ts

@@ -0,0 +1,3 @@
+export interface CreateWebsiteParams {
+    url: string;
+}

package/lib/types/CreateWebsiteParams.js

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

package/lib/{provider → types}/FencyContext.d.ts

@@ -1,5 +1,4 @@
 import { FencyInstance } from '@fencyai/js';
-export declare const FencyContextValue: import("react").Context<FencyContext | undefined>;
 export interface FencyContext {
     fency: FencyInstance;
     loading: boolean;

package/lib/types/FencyContext.js

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

package/lib/types/FencyProviderProps.d.ts

@@ -0,0 +1,8 @@
+import { FencyInstance } from '@fencyai/js';
+export interface FencyProviderProps {
+    fency: Promise<FencyInstance>;
+    children: React.ReactNode;
+    options?: {
+        fetchClientSecret: () => Promise<string>;
+    };
+}

package/lib/types/FencyProviderProps.js

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

package/lib/types/FileUpload.d.ts

@@ -0,0 +1,9 @@
+import { ApiError, FencyFile, FencyUpload, FileUploadCompleted } from '@fencyai/js';
+import { FileUploadStatus } from './FileUploadStatus';
+export interface FileUpload {
+    status: FileUploadStatus;
+    upload: FencyUpload;
+    file: FencyFile | null;
+    error: ApiError | null;
+    onUploadComplete?: (fileUpload: FileUploadCompleted) => void;
+}

package/lib/types/FileUpload.js

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

package/lib/types/FileUploadStatus.d.ts

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

package/lib/types/FileUploadStatus.js

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

package/lib/types/StreamError.d.ts

@@ -0,0 +1,5 @@
+import { ApiError } from '@fencyai/js';
+export interface StreamError {
+    streamId: string;
+    error: ApiError;
+}

package/lib/types/StreamError.js

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

package/lib/types/StreamingChatCompletion.d.ts

@@ -0,0 +1,11 @@
+import { ApiError, NewChatCompletionStreamChunk } from '@fencyai/js';
+import { StreamingChatCompletionData } from './StreamingChatCompletionData';
+export interface StreamingChatCompletion {
+    streamId: string;
+    data: StreamingChatCompletionData | null;
+    error: ApiError | null;
+    response: string;
+    chunks: NewChatCompletionStreamChunk[];
+    loading: boolean;
+    doneStreaming: boolean;
+}

package/lib/types/StreamingChatCompletion.js

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

package/lib/types/StreamingChatCompletionData.d.ts

@@ -0,0 +1,5 @@
+export interface StreamingChatCompletionData {
+    id: string;
+    createdAt: string;
+    streamId: string;
+}

package/lib/types/StreamingChatCompletionData.js

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

package/lib/types/StructuredChatCompletion.d.ts

@@ -0,0 +1,9 @@
+import { ApiError } from '@fencyai/js';
+import { ZodTypeAny } from 'zod';
+import { StructuredChatCompletionData } from './StructuredChatCompletionData';
+export interface StructuredChatCompletion<T extends ZodTypeAny> {
+    triggeredAt: string;
+    data: StructuredChatCompletionData<T> | null;
+    error: ApiError | null;
+    loading: boolean;
+}

package/lib/types/StructuredChatCompletion.js

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

package/lib/types/StructuredChatCompletionData.d.ts

@@ -0,0 +1,7 @@
+import { z, ZodTypeAny } from 'zod';
+export interface StructuredChatCompletionData<T extends ZodTypeAny> {
+    id: string;
+    createdAt: string;
+    response: object;
+    structuredResponse: z.infer<T>;
+}

package/lib/types/StructuredChatCompletionData.js

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

package/lib/types/StructuredChatCompletionResponse.d.ts

@@ -0,0 +1,10 @@
+import { ApiError } from '@fencyai/js';
+import { ZodTypeAny } from 'zod';
+import { StructuredChatCompletionData } from './StructuredChatCompletionData';
+export type StructuredChatCompletionResponse<T extends ZodTypeAny> = {
+    type: 'success';
+    data: StructuredChatCompletionData<T>;
+} | {
+    type: 'error';
+    error: ApiError;
+};

package/lib/types/StructuredChatCompletionResponse.js

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

package/lib/types/SynchronousChatCompletion.d.ts

@@ -0,0 +1,8 @@
+import { ApiError } from '@fencyai/js';
+import { SynchronousChatCompletionData } from './SynchronousChatCompletionData';
+export interface SynchronousChatCompletion {
+    triggeredAt: string;
+    data: SynchronousChatCompletionData | null;
+    error: ApiError | null;
+    loading: boolean;
+}

package/lib/types/SynchronousChatCompletion.js

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

package/lib/types/SynchronousChatCompletionData.d.ts

@@ -0,0 +1,5 @@
+export interface SynchronousChatCompletionData {
+    id: string;
+    createdAt: string;
+    response: string;
+}

package/lib/types/SynchronousChatCompletionData.js

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

package/lib/types/SynchronousChatCompletionResponse.d.ts

@@ -0,0 +1,9 @@
+import { ApiError } from '@fencyai/js';
+import { SynchronousChatCompletionData } from './SynchronousChatCompletionData';
+export type SynchronousChatCompletionResponse = {
+    type: 'success';
+    data: SynchronousChatCompletionData;
+} | {
+    type: 'error';
+    error: ApiError;
+};

package/lib/types/SynchronousChatCompletionResponse.js

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

package/lib/types/UseChatCompletions.d.ts

@@ -0,0 +1,29 @@
+import { ApiError } from '@fencyai/js';
+import { ZodTypeAny } from 'zod';
+import { CombinedChatCompletion } from './CombinedChatCompletion';
+import { SynchronousChatCompletion } from './SynchronousChatCompletion';
+import { StructuredChatCompletion } from './StructuredChatCompletion';
+import { StreamingChatCompletion } from './StreamingChatCompletion';
+import { CreateSynchronousChatCompletionParams } from './CreateSynchronousChatCompletionParams';
+import { SynchronousChatCompletionResponse } from './SynchronousChatCompletionResponse';
+import { CreateStructuredChatCompletionParams } from './CreateStructuredChatCompletionParams';
+import { StructuredChatCompletionResponse } from './StructuredChatCompletionResponse';
+import { CreateStreamingChatCompletionParams } from './CreateStreamingChatCompletionParams';
+export interface UseChatCompletions {
+    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';
+        streamId: string;
+        chatCompletionId: string;
+    } | {
+        type: 'error';
+        error: ApiError;
+    }>;
+}

package/lib/types/UseChatCompletions.js

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

package/lib/types/UseFileUploadProps.d.ts

@@ -0,0 +1,4 @@
+import { FileUploadCompleted } from '@fencyai/js';
+export interface UseFileUploadProps {
+    onUploadComplete: (fileUpload: FileUploadCompleted) => void;
+}

package/lib/types/UseFileUploadProps.js

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

package/lib/types/UseFileUploads.d.ts

@@ -0,0 +1,7 @@
+import { CreateUploadResponse } from '@fencyai/js';
+import { CreateUploadParams } from './CreateUploadParams';
+import { FileUpload } from './FileUpload';
+export interface UseFileUploads {
+    createFileUpload: (params: CreateUploadParams) => Promise<CreateUploadResponse>;
+    fileUploads: FileUpload[];
+}

package/lib/types/UseFileUploads.js

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

package/lib/types/UseStream.d.ts

@@ -0,0 +1,6 @@
+import { CreateStreamRequest, Stream } from '@fencyai/js';
+import { CreateStreamResponse } from './CreateStreamResponse';
+export interface UseStream {
+    createStream: (params: CreateStreamRequest) => Promise<CreateStreamResponse>;
+    stream: Stream | null;
+}

package/lib/types/UseStream.js

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

package/lib/types/UseStreamProps.d.ts

@@ -0,0 +1,10 @@
+import { ChatCompletionStreamCompleted, FileUploadCompleted, NewChatCompletionStreamChunk, StreamNotFound, StreamTimeout } from '@fencyai/js';
+import { StreamError } from './StreamError';
+export interface UseStreamProps {
+    onNewChatCompletionStreamChunk?: (streamData: NewChatCompletionStreamChunk) => void;
+    onChatCompletionStreamCompleted?: (stream: ChatCompletionStreamCompleted) => void;
+    onStreamTimeout?: (error: StreamTimeout) => void;
+    onStreamNotFound?: (error: StreamNotFound) => void;
+    onFileUploadCompleted?: (error: FileUploadCompleted) => void;
+    onStreamError?: (error: StreamError) => void;
+}

package/lib/types/UseStreamProps.js

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

package/lib/types/UseWebsites.d.ts

@@ -0,0 +1,4 @@
+import { CreateWebsiteRequest, CreateWebsiteResponse } from '@fencyai/js';
+export interface UseWebsites {
+    scrapeContent: (params: CreateWebsiteRequest) => Promise<CreateWebsiteResponse>;
+}

package/lib/types/UseWebsites.js

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

package/lib/types/index.d.ts

@@ -0,0 +1,27 @@
+export * from './FencyProviderProps';
+export * from './FencyContext';
+export * from './CreateOpenAiChatCompletionParams';
+export * from './CreateGeminiChatCompletionParams';
+export * from './CreateAnthropicChatCompletionParams';
+export * from './SynchronousChatCompletionData';
+export * from './SynchronousChatCompletion';
+export * from './SynchronousChatCompletionResponse';
+export * from './CreateSynchronousChatCompletionParams';
+export * from './StreamingChatCompletionData';
+export * from './StreamingChatCompletion';
+export * from './CreateStreamingChatCompletionParams';
+export * from './StructuredChatCompletionData';
+export * from './StructuredChatCompletion';
+export * from './StructuredChatCompletionResponse';
+export * from './CreateStructuredChatCompletionParams';
+export * from './CombinedChatCompletion';
+export * from './UseChatCompletions';
+export * from './UseStream';
+export * from './CreateStreamResponse';
+export * from './StreamError';
+export * from './UseStreamProps';
+export * from './UseFileUploads';
+export * from './UseFileUploadProps';
+export * from './FileUploadStatus';
+export * from './FileUpload';
+export * from './UseWebsites';

package/lib/types/index.js

@@ -0,0 +1,36 @@
+// Provider types
+export * from './FencyProviderProps';
+export * from './FencyContext';
+// Chat completion parameter types
+export * from './CreateOpenAiChatCompletionParams';
+export * from './CreateGeminiChatCompletionParams';
+export * from './CreateAnthropicChatCompletionParams';
+// Synchronous chat completion types
+export * from './SynchronousChatCompletionData';
+export * from './SynchronousChatCompletion';
+export * from './SynchronousChatCompletionResponse';
+export * from './CreateSynchronousChatCompletionParams';
+// Streaming chat completion types
+export * from './StreamingChatCompletionData';
+export * from './StreamingChatCompletion';
+export * from './CreateStreamingChatCompletionParams';
+// Structured chat completion types
+export * from './StructuredChatCompletionData';
+export * from './StructuredChatCompletion';
+export * from './StructuredChatCompletionResponse';
+export * from './CreateStructuredChatCompletionParams';
+// Combined chat completion types
+export * from './CombinedChatCompletion';
+export * from './UseChatCompletions';
+// Stream types
+export * from './UseStream';
+export * from './CreateStreamResponse';
+export * from './StreamError';
+export * from './UseStreamProps';
+// File upload types
+export * from './UseFileUploads';
+export * from './UseFileUploadProps';
+export * from './FileUploadStatus';
+export * from './FileUpload';
+// Website types
+export * from './UseWebsites';

package/lib/useChatCompletions/index.d.ts

@@ -1,35 +1,2 @@
-import { ApiError } from '@fencyai/js';
-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 {};
+import { UseChatCompletions } from '../types/UseChatCompletions';
+export declare function useChatCompletions(): UseChatCompletions;

package/lib/useChatCompletions/index.js

@@ -1,8 +1,9 @@
+// hooks/useChatCompletion.ts
 import { useMemo } from 'react';
 import { useFencyContext } from '../provider/useFencyContext';
-import { useStreamingChatCompletions, } from './useStreamingChatCompletions';
-import { useStructuredChatCompletions, } from './useStructuredChatCompletions';
-import { useSynchronousChatCompletions, } from './useSynchronousChatCompletions';
+import { useStreamingChatCompletions } from './useStreamingChatCompletions';
+import { useStructuredChatCompletions } from './useStructuredChatCompletions';
+import { useSynchronousChatCompletions } from './useSynchronousChatCompletions';
 export function useChatCompletions() {
     const context = useFencyContext();
     const synchronousChatCompletions = useSynchronousChatCompletions(context);

package/lib/useChatCompletions/useStreamingChatCompletions.d.ts

@@ -1,36 +1,16 @@
-import { ChatCompletionStream } from '@fencyai/js';
 import { ApiError } from '@fencyai/js';
-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;
-}
+import { CreateStreamingChatCompletionParams } from '../types/CreateStreamingChatCompletionParams';
+import { StreamingChatCompletion } from '../types/StreamingChatCompletion';
+import { FencyContext } from '../types/FencyContext';
 export declare const useStreamingChatCompletions: (context: FencyContext) => {
     chatCompletions: StreamingChatCompletion[];
     createStreamingChatCompletion: (params: CreateStreamingChatCompletionParams) => Promise<{
         type: "success";
-        chatCompletionStreamId: string;
+        streamId: string;
         chatCompletionId: string;
     } | {
         type: "error";
         error: ApiError;
     }>;
-    stream: ChatCompletionStream | null;
+    stream: import("@fencyai/js").Stream | null;
 };

package/lib/useChatCompletions/useStreamingChatCompletions.js

@@ -1,18 +1,32 @@
-import { createChatCompletion, createChatCompletionStream, } from '@fencyai/js';
+import { createChatCompletion } from '@fencyai/js';
 import { useCallback, useEffect, useState } from 'react';
-import { useEventSource } from '../useEventSource';
+import { useStream } from '../useStream';
 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}`);
+    const [chunks, setChunks] = useState([]);
+    const { stream, createStream } = useStream({
+        onNewChatCompletionStreamChunk: (streamData) => {
+            if (streamData.type === 'NewChatCompletionStreamChunk') {
+                setChunks((prev) => [...prev, streamData]);
             }
-            setCompletedStreamIds((prev) => [...prev, streamId]);
+        },
+        onChatCompletionStreamCompleted: (stream) => {
+            setCompletedStreamIds((prev) => [...prev, stream.streamId]);
+        },
+        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,
+                        error: error.error,
+                    },
+                ];
+            });
         },
     });
     useEffect(() => {
@@ -29,13 +43,6 @@ export const useStreamingChatCompletions = (context) => {
             });
         });
     }, [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) {
@@ -65,12 +72,10 @@ export const useStreamingChatCompletions = (context) => {
     }, [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,
+        const streamResponse = await createStream({
+            type: 'ChatCompletionStream',
         });
         if (streamResponse.type === 'success') {
-            setStream(streamResponse.stream);
             setChatCompletions([
                 ...chatCompletions,
                 {
@@ -131,7 +136,7 @@ export const useStreamingChatCompletions = (context) => {
                 ]);
                 return {
                     type: 'success',
-                    chatCompletionStreamId: streamResponse.stream.id,
+                    streamId: streamResponse.stream.id,
                     chatCompletionId: chatCompletion.completion.id,
                 };
             }

package/lib/useChatCompletions/useStructuredChatCompletions.d.ts

@@ -1,31 +1,8 @@
-import { ApiError } from '@fencyai/js';
 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;
-}
+import { CreateStructuredChatCompletionParams } from '../types/CreateStructuredChatCompletionParams';
+import { StructuredChatCompletion } from '../types/StructuredChatCompletion';
+import { StructuredChatCompletionResponse } from '../types/StructuredChatCompletionResponse';
+import { FencyContext } from '../types/FencyContext';
 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/useSynchronousChatCompletions.d.ts

@@ -1,29 +1,7 @@
-import { ApiError } from '@fencyai/js';
-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;
-}
+import { CreateSynchronousChatCompletionParams } from '../types/CreateSynchronousChatCompletionParams';
+import { SynchronousChatCompletion } from '../types/SynchronousChatCompletion';
+import { SynchronousChatCompletionResponse } from '../types/SynchronousChatCompletionResponse';
+import { FencyContext } from '../types/FencyContext';
 export declare const useSynchronousChatCompletions: (context: FencyContext) => {
     chatCompletions: SynchronousChatCompletion[];
     createSynchronousChatCompletion: (params: CreateSynchronousChatCompletionParams) => Promise<SynchronousChatCompletionResponse>;

package/lib/useEventSource.d.ts

@@ -1,13 +1,14 @@
+export type Message = {
+    url: string;
+    data: string;
+};
+export type EventSource = {
+    url: string;
+};
 export declare function useEventSource(props?: {
-    onDone?: (url: string) => void;
+    onError: (streamId: string) => void;
+    onMessage: (message: Message) => void;
 }): {
-    chunks: ChatCompletionChunk[];
-    setUrl: import("react").Dispatch<import("react").SetStateAction<string | null | undefined>>;
-    url: string | null | undefined;
+    setSource: import("react").Dispatch<import("react").SetStateAction<EventSource | null>>;
+    source: EventSource | null;
 };
-export interface ChatCompletionChunk {
-    chatCompletionId: string;
-    streamId: string;
-    timestamp: string;
-    content: string;
-}

package/lib/useEventSource.js

@@ -1,39 +1,28 @@
 import { useEffect, useState } from 'react';
 export function useEventSource(props) {
-    const [chunks, setChunks] = useState([]);
-    const [url, setUrl] = useState();
+    const [source, setSource] = useState(null);
     useEffect(() => {
-        if (!url)
+        if (!source)
             return;
-        const eventSource = new EventSource(url);
+        const eventSource = new EventSource(source.url);
         eventSource.onmessage = (message) => {
-            if (message.data === '__END_OF_STREAM__') {
-                eventSource.close();
-                setUrl(null); // Clear URL to prevent reconnection
-                props?.onDone?.(url);
-                return;
-            }
-            const chunk = getChatCompletionChunk(message);
-            if (chunk) {
-                setChunks((prev) => [...prev, chunk]);
-            }
-            else {
-                console.warn('Unknown message:', message);
-            }
+            props?.onMessage({
+                url: source.url,
+                data: base64Decode(message.data),
+            });
         };
         eventSource.onerror = (error) => {
             console.error('EventSource error:', error);
-            eventSource.close();
-            setUrl(null); // Clear URL on error
+            props?.onError(source.url);
+            setSource(null);
         };
         return () => {
             eventSource.close();
         };
-    }, [url]);
+    }, [source]);
     return {
-        chunks,
-        setUrl,
-        url,
+        setSource,
+        source,
     };
 }
 function base64Decode(base64) {
@@ -47,24 +36,3 @@ function base64Decode(base64) {
     // Decode UTF-8 bytes -> proper string
     return new TextDecoder('utf-8').decode(bytes);
 }
-const getChatCompletionChunk = (message) => {
-    try {
-        const json = JSON.parse(base64Decode(message.data));
-        if (isChatCompletionChunk(json)) {
-            return json;
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('Error parsing message:', error);
-        return null;
-    }
-};
-const isChatCompletionChunk = (data) => {
-    return (typeof data === 'object' &&
-        data !== null &&
-        'chatCompletionId' in data &&
-        'streamId' in data &&
-        'timestamp' in data &&
-        'content' in data);
-};

package/lib/useFileUploads/index.d.ts

@@ -0,0 +1,3 @@
+import { UseFileUploadProps } from '../types/UseFileUploadProps';
+import { UseFileUploads } from '../types/UseFileUploads';
+export declare function useFileUploads(props: UseFileUploadProps): UseFileUploads;

package/lib/useFileUploads/index.js

@@ -0,0 +1,56 @@
+import { createUpload } from '@fencyai/js';
+import { useState } from 'react';
+import { useFencyContext } from '../provider/useFencyContext';
+import { useStream } from '../useStream';
+export function useFileUploads(props) {
+    const [fileUploads, setFileUploads] = useState([]);
+    const context = useFencyContext();
+    const { createStream } = useStream({
+        onFileUploadCompleted: (streamData) => {
+            props.onUploadComplete?.(streamData);
+            setFileUploads((prev) => prev.map((fileUpload) => fileUpload.upload.id === streamData.uploadId
+                ? { ...fileUpload, status: 'upload_complete' }
+                : fileUpload));
+        },
+    });
+    const createFileUpload = async (params) => {
+        const stream = await createStream({
+            type: 'FileUploadStream',
+        });
+        if (stream.type === 'success') {
+            const response = await createUpload({
+                pk: context.fency.publishableKey,
+                request: {
+                    streamId: stream.stream.id,
+                    fileName: params.fileName,
+                    fileType: params.fileType,
+                    fileSize: params.fileSize,
+                },
+                baseUrl: context.fency.baseUrl,
+            });
+            if (response.type === 'success') {
+                setFileUploads([
+                    ...fileUploads,
+                    {
+                        status: 'uploading',
+                        upload: response.upload,
+                        file: null,
+                        error: null,
+                        onUploadComplete: props.onUploadComplete,
+                    },
+                ]);
+            }
+            return response;
+        }
+        else {
+            return {
+                type: 'error',
+                error: stream.error,
+            };
+        }
+    };
+    return {
+        createFileUpload,
+        fileUploads,
+    };
+}

package/lib/useStream/index.d.ts

@@ -0,0 +1,3 @@
+import { UseStream } from '../types/UseStream';
+import { UseStreamProps } from '../types/UseStreamProps';
+export declare const useStream: (props?: UseStreamProps) => UseStream;

package/lib/useStream/index.js

@@ -0,0 +1,87 @@
+import { createStream as createStreamApi } from '@fencyai/js';
+import { useState } from 'react';
+import { useFencyContext } from '../provider/useFencyContext';
+import { useEventSource } from '../useEventSource';
+export const useStream = (props) => {
+    const context = useFencyContext();
+    const [urlToStreamIdMapping, setUrlToStreamIdMapping] = useState({});
+    const [stream, setStream] = useState(null);
+    const eventSource = useEventSource({
+        onError: (url) => {
+            console.error('Stream error:', url);
+        },
+        onMessage: (message) => {
+            const streamId = requireStreamId(message.url, urlToStreamIdMapping);
+            const streamData = toStreamData(message.data, streamId);
+            switch (streamData?.type) {
+                case 'NewChatCompletionStreamChunk':
+                    props?.onNewChatCompletionStreamChunk?.(streamData);
+                    return true;
+                case 'ChatCompletionStreamCompleted':
+                    props?.onChatCompletionStreamCompleted?.(streamData);
+                    return true;
+                case 'StreamTimeout':
+                    props?.onStreamTimeout?.(streamData);
+                    return true;
+                case 'StreamNotFound':
+                    props?.onStreamNotFound?.(streamData);
+                    return true;
+                case 'FileUploadCompleted':
+                    props?.onFileUploadCompleted?.(streamData);
+                    return true;
+                default:
+                    return false;
+            }
+        },
+    });
+    const createStream = async (params) => {
+        const response = await createStreamApi({
+            pk: context.fency.publishableKey,
+            baseUrl: context.fency.baseUrl,
+            request: params,
+        });
+        if (response.type === 'success') {
+            setStream(response.stream);
+            const url = `${context.fency.baseUrl}/v1/pub/streams/${response.stream.id}?pk=${context.fency.publishableKey}`;
+            setUrlToStreamIdMapping((prev) => ({
+                ...prev,
+                [url]: response.stream.id,
+            }));
+            eventSource.setSource({
+                url,
+            });
+        }
+        return response;
+    };
+    return {
+        createStream: createStream,
+        stream,
+    };
+};
+const requireStreamId = (url, urlToStreamIdMapping) => {
+    const streamId = urlToStreamIdMapping[url];
+    if (!streamId) {
+        throw new Error(`Stream ID not found for URL: ${url}`);
+    }
+    return streamId;
+};
+const toStreamData = (data, streamId) => {
+    try {
+        const json = JSON.parse(data);
+        if (isStreamData(json)) {
+            return json;
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('Error parsing message:', error);
+        return null;
+    }
+};
+const isStreamData = (data) => {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'type' in data &&
+        'streamId' in data &&
+        'timestamp' in data);
+};

package/lib/useWebsites/index.d.ts

@@ -0,0 +1,2 @@
+import { UseWebsites } from '../types/UseWebsites';
+export declare function useWebsites(): UseWebsites;

package/lib/useWebsites/index.js

@@ -0,0 +1,16 @@
+import { createWebsite } from '@fencyai/js';
+import { useFencyContext } from '../provider/useFencyContext';
+export function useWebsites() {
+    const context = useFencyContext();
+    const scrapeContent = async (params) => {
+        const response = await createWebsite({
+            pk: context.fency.publishableKey,
+            request: params,
+            baseUrl: context.fency.baseUrl,
+        });
+        return response;
+    };
+    return {
+        scrapeContent,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fencyai/react",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "> TODO: description",
   "author": "staklau <steinaageklaussen@gmail.com>",
   "homepage": "",
@@ -36,7 +36,7 @@
     "zod": "^4.0.5"
   },
   "devDependencies": {
-    "@fencyai/js": "^0.1.42",
+    "@fencyai/js": "^0.1.43",
     "@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.42",
+    "@fencyai/js": "^0.1.43",
     "react": ">=16.8.0"
   },
-  "gitHead": "a8e44437447dc885782eaf34c5df4cca71012e3f"
+  "gitHead": "0c797d40ee1243848951a464a5140d9defbb5785"
 }

package/lib/useChatCompletions/types.d.ts

@@ -1,24 +0,0 @@
-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;
-}