@ragbits/api-client 0.0.2 → 1.3.0

package/dist/index.cjs

@@ -20,34 +20,45 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AuthType: () => AuthType,
   ChatResponseType: () => ChatResponseType,
   FeedbackType: () => FeedbackType,
+  LiveUpdateType: () => LiveUpdateType,
   MessageRole: () => MessageRole,
   RagbitsClient: () => RagbitsClient
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/types.ts
-var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
-  MessageRole2["USER"] = "user";
-  MessageRole2["ASSISTANT"] = "assistant";
-  MessageRole2["SYSTEM"] = "system";
-  return MessageRole2;
-})(MessageRole || {});
-var ChatResponseType = /* @__PURE__ */ ((ChatResponseType2) => {
-  ChatResponseType2["MESSAGE"] = "message";
-  ChatResponseType2["REFERENCE"] = "reference";
-  ChatResponseType2["STATE_UPDATE"] = "state_update";
-  ChatResponseType2["TEXT"] = "text";
-  ChatResponseType2["MESSAGE_ID"] = "message_id";
-  ChatResponseType2["CONVERSATION_ID"] = "conversation_id";
-  return ChatResponseType2;
-})(ChatResponseType || {});
-var FeedbackType = /* @__PURE__ */ ((FeedbackType2) => {
-  FeedbackType2["LIKE"] = "like";
-  FeedbackType2["DISLIKE"] = "dislike";
-  return FeedbackType2;
-})(FeedbackType || {});
+// src/autogen.types.ts
+var ChatResponseType = {
+  Text: "text",
+  Reference: "reference",
+  StateUpdate: "state_update",
+  MessageId: "message_id",
+  ConversationId: "conversation_id",
+  LiveUpdate: "live_update",
+  FollowupMessages: "followup_messages",
+  Image: "image",
+  ChunkedContent: "chunked_content",
+  ClearMessage: "clear_message",
+  Usage: "usage"
+};
+var FeedbackType = {
+  Like: "like",
+  Dislike: "dislike"
+};
+var LiveUpdateType = {
+  Start: "START",
+  Finish: "FINISH"
+};
+var MessageRole = {
+  User: "user",
+  Assistant: "assistant",
+  System: "system"
+};
+var AuthType = {
+  Credentials: "credentials"
+};
 
 // src/index.ts
 var RagbitsClient = class {
@@ -55,7 +66,15 @@ var RagbitsClient = class {
    * @param config - Configuration object
    */
   constructor(config = {}) {
-    this.baseUrl = config.baseUrl || "http://127.0.0.1:8000";
+    this.chunkQueue = /* @__PURE__ */ new Map();
+    this.baseUrl = config.baseUrl ?? "";
+    this.auth = config.auth;
+    if (this.baseUrl.endsWith("/")) {
+      this.baseUrl = this.baseUrl.slice(0, -1);
+    }
+    if (!this.baseUrl) {
+      return;
+    }
     try {
       new URL(this.baseUrl);
     } catch {
@@ -63,9 +82,6 @@ var RagbitsClient = class {
         `Invalid base URL: ${this.baseUrl}. Please provide a valid URL.`
       );
     }
-    if (this.baseUrl.endsWith("/")) {
-      this.baseUrl = this.baseUrl.slice(0, -1);
-    }
   }
   /**
    * Get the base URL used by this client
@@ -85,12 +101,20 @@ var RagbitsClient = class {
    * @private
    */
   async _makeRequest(url, options = {}) {
-    const defaultOptions = {
-      headers: {
-        "Content-Type": "application/json"
-      }
+    const defaultHeaders = {
+      "Content-Type": "application/json"
+    };
+    const headers = {
+      ...defaultHeaders,
+      ...this.normalizeHeaders(options.headers)
     };
-    const response = await fetch(url, { ...defaultOptions, ...options });
+    if (this.auth?.getToken) {
+      headers["Authorization"] = `Bearer ${this.auth.getToken()}`;
+    }
+    const response = await fetch(url, { ...options, headers });
+    if (response.status === 401) {
+      this.auth?.onUnauthorized?.();
+    }
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`);
     }
@@ -98,7 +122,7 @@ var RagbitsClient = class {
   }
   /**
    * Method to make API requests to known endpoints only
-   * @param endpoint - API endpoint path (must be predefined)
+   * @param endpoint - API endpoint path
    * @param options - Typed request options for the specific endpoint
    */
   async makeRequest(endpoint, options) {
@@ -118,25 +142,26 @@ var RagbitsClient = class {
       requestOptions.body = typeof body === "string" ? body : JSON.stringify(body);
     }
     const response = await this._makeRequest(
-      this._buildApiUrl(endpoint),
+      this._buildApiUrl(endpoint.toString()),
       requestOptions
     );
     return response.json();
   }
   /**
    * Method for streaming requests to known endpoints only
-   * @param endpoint - Streaming endpoint path (must be predefined)
+   * @param endpoint - Streaming endpoint path
    * @param data - Request data
    * @param callbacks - Stream callbacks
    * @param signal - Optional AbortSignal for cancelling the request
    */
-  makeStreamRequest(endpoint, data, callbacks, signal) {
+  makeStreamRequest(endpoint, data, callbacks, signal, customHeaders) {
     let isCancelled = false;
     const processStream = async (response) => {
       const reader = response.body?.pipeThrough(new TextDecoderStream()).getReader();
       if (!reader) {
         throw new Error("Response body is null");
       }
+      let buffer = "";
       while (!isCancelled && !signal?.aborted) {
         try {
           const { value, done } = await reader.read();
@@ -144,7 +169,9 @@ var RagbitsClient = class {
             callbacks.onClose?.();
             break;
           }
-          const lines = value.split("\n");
+          buffer += value;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
           for (const line of lines) {
             if (!line.startsWith("data: ")) continue;
             try {
@@ -152,6 +179,10 @@ var RagbitsClient = class {
               const parsedData = JSON.parse(
                 jsonString
               );
+              if (parsedData.type === ChatResponseType.ChunkedContent) {
+                this.handleChunkedContent(parsedData, callbacks);
+                continue;
+              }
               await callbacks.onMessage(parsedData);
             } catch (parseError) {
               console.error("Error parsing JSON:", parseError);
@@ -161,6 +192,9 @@ var RagbitsClient = class {
             }
           }
         } catch (streamError) {
+          if (signal?.aborted) {
+            return;
+          }
           console.error("Stream error:", streamError);
           await callbacks.onError(new Error("Error reading stream"));
           break;
@@ -169,15 +203,29 @@ var RagbitsClient = class {
     };
     const startStream = async () => {
       try {
-        const response = await fetch(this._buildApiUrl(endpoint), {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Accept: "text/event-stream"
-          },
-          body: JSON.stringify(data),
-          signal
-        });
+        const defaultHeaders = {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        };
+        const headers = {
+          ...defaultHeaders,
+          ...customHeaders
+        };
+        if (this.auth?.getToken) {
+          headers["Authorization"] = `Bearer ${this.auth.getToken()}`;
+        }
+        const response = await fetch(
+          this._buildApiUrl(endpoint.toString()),
+          {
+            method: "POST",
+            headers,
+            body: JSON.stringify(data),
+            signal
+          }
+        );
+        if (response.status === 401) {
+          this.auth?.onUnauthorized?.();
+        }
         if (!response.ok) {
           throw new Error(`HTTP error! status: ${response.status}`);
         }
@@ -201,11 +249,68 @@ var RagbitsClient = class {
       isCancelled = true;
     };
   }
+  normalizeHeaders(init) {
+    if (!init) return {};
+    if (init instanceof Headers) {
+      return Object.fromEntries(init.entries());
+    }
+    if (Array.isArray(init)) {
+      return Object.fromEntries(init);
+    }
+    return init;
+  }
+  async handleChunkedContent(data, callbacks) {
+    const response = data;
+    const content = response.content;
+    const {
+      content_type: contentType,
+      id,
+      chunk_index: chunkIndex,
+      total_chunks: totalChunks,
+      mime_type: mimeType,
+      data: chunkData
+    } = content;
+    if (!this.chunkQueue.has(id)) {
+      this.chunkQueue.set(id, {
+        chunks: /* @__PURE__ */ new Map(),
+        totalChunks,
+        mimeType
+      });
+    }
+    const imageInfo = this.chunkQueue.get(id);
+    imageInfo.chunks.set(chunkIndex, chunkData);
+    if (imageInfo.chunks.size !== totalChunks) return;
+    const sortedChunks = Array.from(
+      { length: totalChunks },
+      (_, i) => imageInfo.chunks.get(i)
+    );
+    const completeBase64 = sortedChunks.join("");
+    try {
+      atob(completeBase64);
+    } catch (e) {
+      this.chunkQueue.delete(id);
+      console.error("\u274C Invalid base64 data: ", e);
+      await callbacks.onError(new Error("Error reading stream"));
+    }
+    if (contentType === ChatResponseType.Image) {
+      const completeImageResponse = {
+        type: ChatResponseType.Image,
+        content: {
+          id,
+          url: `${imageInfo.mimeType},${completeBase64}`
+        }
+      };
+      await callbacks.onMessage(completeImageResponse);
+    }
+    this.chunkQueue.delete(id);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AuthType,
   ChatResponseType,
   FeedbackType,
+  LiveUpdateType,
   MessageRole,
   RagbitsClient
 });

package/dist/index.d.ts

@@ -1,225 +1,11 @@
-import { RJSFSchema } from '@rjsf/utils';
-
-/**
- * Message roles for chat conversations
- */
-declare enum MessageRole {
-    USER = "user",
-    ASSISTANT = "assistant",
-    SYSTEM = "system"
-}
-/**
- * Message structure for chat conversations
- */
-interface Message {
-    role: MessageRole;
-    content: string;
-    id?: string;
-}
-/**
- * Reference structure for document references
- */
-interface Reference {
-    title: string;
-    content: string;
-    url?: string;
-}
-/**
- * Response types from the API
- */
-declare enum ChatResponseType {
-    MESSAGE = "message",
-    REFERENCE = "reference",
-    STATE_UPDATE = "state_update",
-    TEXT = "text",
-    MESSAGE_ID = "message_id",
-    CONVERSATION_ID = "conversation_id"
-}
-/**
- * Feedback types for user feedback
- */
-declare enum FeedbackType {
-    LIKE = "like",
-    DISLIKE = "dislike"
-}
-/**
- * Server state interface for state updates
- */
-interface ServerState {
-    state: Record<string, unknown>;
-    signature: string;
-}
-/**
- * Specific chat response types
- */
-interface MessageIdChatResponse {
-    type: ChatResponseType.MESSAGE_ID;
-    content: string;
-}
-interface TextChatResponse {
-    type: ChatResponseType.TEXT;
-    content: string;
-}
-interface ReferenceChatResponse {
-    type: ChatResponseType.REFERENCE;
-    content: Reference;
-}
-interface ConversationIdChatResponse {
-    type: ChatResponseType.CONVERSATION_ID;
-    content: string;
-}
-interface StateUpdateChatResponse {
-    type: ChatResponseType.STATE_UPDATE;
-    content: ServerState;
-}
-/**
- * Typed chat response union
- */
-type TypedChatResponse = TextChatResponse | ReferenceChatResponse | MessageIdChatResponse | ConversationIdChatResponse | StateUpdateChatResponse;
-/**
- * Base chat request to the API
- */
-interface ChatRequest {
-    message: string;
-    history: Message[];
-    context?: Record<string, unknown>;
-}
-/**
- * Feedback request to the API
- */
-interface FeedbackRequest {
-    message_id: string;
-    feedback: FeedbackType;
-    payload: Record<string, unknown> | null;
-}
-/**
- * Feedback response from the API
- */
-interface FeedbackResponse {
-    status: string;
-}
-/**
- * UI customization configuration
- */
-interface UICustomization {
-    header: {
-        title?: string;
-        subtitle?: string;
-        logo?: string;
-    };
-    welcome_message?: string;
-}
-/**
- * Configuration response from the API
- */
-interface ConfigResponse {
-    feedback: {
-        like: {
-            enabled: boolean;
-            form: RJSFSchema | null;
-        };
-        dislike: {
-            enabled: boolean;
-            form: RJSFSchema | null;
-        };
-    };
-    customization: UICustomization | null;
-}
-/**
- * Configuration for the client
- */
-interface ClientConfig {
-    baseUrl?: string;
-}
-/**
- * Callbacks for handling streaming responses
- */
-interface StreamCallbacks<T, E = Error> {
-    onMessage: (data: T) => void | Promise<void>;
-    onError: (error: E) => void | Promise<void>;
-    onClose?: () => void | Promise<void>;
-}
-/**
- * Regular API endpoint definitions with their request/response types
- */
-interface ApiEndpoints {
-    '/api/config': {
-        method: 'GET';
-        request: never;
-        response: ConfigResponse;
-    };
-    '/api/feedback': {
-        method: 'POST';
-        request: FeedbackRequest;
-        response: FeedbackResponse;
-    };
-}
-/**
- * Streaming API endpoint definitions with their request/stream response types
- */
-interface StreamingEndpoints {
-    '/api/chat': {
-        method: 'POST';
-        request: ChatRequest;
-        stream: TypedChatResponse;
-    };
-}
-/**
- * Extract endpoint paths as a union type
- */
-type ApiEndpointPath = keyof ApiEndpoints;
-/**
- * Extract streaming endpoint paths as a union type
- */
-type StreamingEndpointPath = keyof StreamingEndpoints;
-/**
- * Extract request type for a specific API endpoint
- */
-type ApiEndpointRequest<T extends ApiEndpointPath> = ApiEndpoints[T]['request'];
-/**
- * Extract response type for a specific API endpoint
- */
-type ApiEndpointResponse<T extends ApiEndpointPath> = ApiEndpoints[T]['response'];
-/**
- * Extract HTTP method for a specific API endpoint
- */
-type ApiEndpointMethod<T extends ApiEndpointPath> = ApiEndpoints[T]['method'];
-/**
- * Extract request type for a specific streaming endpoint
- */
-type StreamingEndpointRequest<T extends StreamingEndpointPath> = StreamingEndpoints[T]['request'];
-/**
- * Extract stream response type for a specific streaming endpoint
- */
-type StreamingEndpointStream<T extends StreamingEndpointPath> = StreamingEndpoints[T]['stream'];
-/**
- * Extract HTTP method for a specific streaming endpoint
- */
-type StreamingEndpointMethod<T extends StreamingEndpointPath> = StreamingEndpoints[T]['method'];
-/**
- * Generic request options for API endpoints with typed methods and body
- */
-interface TypedApiRequestOptions<T extends ApiEndpointPath> {
-    method?: ApiEndpointMethod<T>;
-    body?: ApiEndpointRequest<T> extends never ? undefined : ApiEndpointRequest<T>;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-}
-/**
- * Typed request options for specific streaming endpoints
- */
-interface TypedStreamRequestOptions<T extends StreamingEndpointPath> {
-    method?: StreamingEndpointMethod<T>;
-    body?: StreamingEndpointRequest<T>;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-}
-
+import type { ClientConfig, StreamCallbacks, BaseApiEndpoints, EndpointDefinition, EndpointResponse, RequestOptions, BaseStreamingEndpoints, EndpointRequest } from './types';
 /**
  * Client for communicating with the Ragbits API
  */
-declare class RagbitsClient {
+export declare class RagbitsClient {
     private readonly baseUrl;
+    private readonly auth;
+    private chunkQueue;
     /**
      * @param config - Configuration object
      */
@@ -240,18 +26,24 @@ declare class RagbitsClient {
     private _makeRequest;
     /**
      * Method to make API requests to known endpoints only
-     * @param endpoint - API endpoint path (must be predefined)
+     * @param endpoint - API endpoint path
      * @param options - Typed request options for the specific endpoint
      */
-    makeRequest<T extends ApiEndpointPath>(endpoint: T, options?: TypedApiRequestOptions<T>): Promise<ApiEndpointResponse<T>>;
+    makeRequest<Endpoints extends {
+        [K in keyof Endpoints]: EndpointDefinition;
+    } = BaseApiEndpoints, URL extends keyof Endpoints = keyof Endpoints>(endpoint: URL, options?: RequestOptions<URL, Endpoints>): Promise<EndpointResponse<URL, Endpoints>>;
     /**
      * Method for streaming requests to known endpoints only
-     * @param endpoint - Streaming endpoint path (must be predefined)
+     * @param endpoint - Streaming endpoint path
      * @param data - Request data
      * @param callbacks - Stream callbacks
      * @param signal - Optional AbortSignal for cancelling the request
      */
-    makeStreamRequest<T extends StreamingEndpointPath>(endpoint: T, data: StreamingEndpointRequest<T>, callbacks: StreamCallbacks<StreamingEndpointStream<T>>, signal?: AbortSignal): () => void;
-}
-
-export { type ApiEndpointMethod, type ApiEndpointPath, type ApiEndpointRequest, type ApiEndpointResponse, type ApiEndpoints, type ChatRequest, ChatResponseType, type ClientConfig, type ConfigResponse, type FeedbackRequest, type FeedbackResponse, FeedbackType, type Message, MessageRole, RagbitsClient, type Reference, type ServerState, type StreamCallbacks, type StreamingEndpointMethod, type StreamingEndpointPath, type StreamingEndpointRequest, type StreamingEndpointStream, type StreamingEndpoints, type TypedApiRequestOptions, type TypedChatResponse, type TypedStreamRequestOptions, type UICustomization };
+    makeStreamRequest<Endpoints extends {
+        [K in keyof Endpoints]: EndpointDefinition;
+    } = BaseStreamingEndpoints, URL extends keyof Endpoints = keyof Endpoints>(endpoint: URL, data: EndpointRequest<URL, Endpoints>, callbacks: StreamCallbacks<EndpointResponse<URL, Endpoints>>, signal?: AbortSignal, customHeaders?: Record<string, string>): () => void;
+    private normalizeHeaders;
+    private handleChunkedContent;
+}
+export * from './types';
+export * from './autogen.types';