@ragbits/api-client 0.0.2 → 1.3.0

package/dist/index.js

@@ -1,24 +1,33 @@
-// 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 {
@@ -26,7 +35,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 {
@@ -34,9 +51,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
@@ -56,12 +70,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}`);
     }
@@ -69,7 +91,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) {
@@ -89,25 +111,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();
@@ -115,7 +138,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 {
@@ -123,6 +148,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);
@@ -132,6 +161,9 @@ var RagbitsClient = class {
             }
           }
         } catch (streamError) {
+          if (signal?.aborted) {
+            return;
+          }
           console.error("Stream error:", streamError);
           await callbacks.onError(new Error("Error reading stream"));
           break;
@@ -140,15 +172,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}`);
         }
@@ -172,10 +218,67 @@ 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);
+  }
 };
 export {
+  AuthType,
   ChatResponseType,
   FeedbackType,
+  LiveUpdateType,
   MessageRole,
   RagbitsClient
 };

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+import { ConfigResponse, FeedbackRequest, FeedbackResponse, ChatRequest, ChatResponse, LogoutRequest, LoginRequest, LoginResponse } from './autogen.types';
+export interface GenericResponse {
+    success: boolean;
+}
+/**
+ * Configuration for the client
+ */
+export interface ClientConfig {
+    baseUrl?: string;
+    auth?: {
+        getToken?: () => string;
+        onUnauthorized?: () => Promise<void> | void;
+    };
+}
+/**
+ * Callbacks for handling streaming responses
+ */
+export interface StreamCallbacks<T, E = Error> {
+    onMessage: (data: T) => void | Promise<void>;
+    onError: (error: E) => void | Promise<void>;
+    onClose?: () => void | Promise<void>;
+}
+export interface EndpointDefinition<Req = any, Res = any> {
+    method: string;
+    request: Req;
+    response: Res;
+}
+/**
+ * Base predefined API endpoint definitions with their request/response types
+ */
+export interface BaseApiEndpoints {
+    '/api/config': EndpointDefinition<never, ConfigResponse>;
+    '/api/feedback': EndpointDefinition<FeedbackRequest, FeedbackResponse>;
+    '/api/auth/login': EndpointDefinition<LoginRequest, LoginResponse>;
+    '/api/auth/logout': EndpointDefinition<LogoutRequest, GenericResponse>;
+}
+/**
+ * Streaming API endpoint definitions with their request/stream response types
+ */
+export interface BaseStreamingEndpoints {
+    '/api/chat': EndpointDefinition<ChatRequest, ChatResponse>;
+}
+/**
+ * Extract endpoint paths as a union type
+ */
+export type EndpointPath<Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition;
+}> = keyof Endpoints;
+/**
+ * Extract request type for a specific API endpoint
+ */
+export type EndpointRequest<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition;
+}> = Endpoints[URL]['request'];
+/**
+ * Extract response type for a specific API endpoint
+ */
+export type EndpointResponse<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition;
+}> = Endpoints[URL]['response'];
+/**
+ * Extract HTTP method for a specific API endpoint
+ */
+export type EndpointMethod<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition;
+}> = Endpoints[URL]['method'];
+/**
+ * Generic request options for API endpoints with typed methods and body
+ */
+export interface RequestOptions<URL extends keyof Endpoints, Endpoints extends {
+    [K in keyof Endpoints]: EndpointDefinition;
+}> {
+    method?: Endpoints[URL]['method'];
+    body?: Endpoints[URL]['request'] extends never ? undefined : Endpoints[URL]['request'];
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}

package/package.json

@@ -1,7 +1,11 @@
 {
     "name": "@ragbits/api-client",
-    "version": "0.0.2",
+    "version": "1.3.0",
     "description": "JavaScript client for the Ragbits API",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/deepsense-ai/ragbits"
+     },
     "main": "dist/index.cjs",
     "module": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -14,14 +18,15 @@
         }
     },
     "scripts": {
-        "build": "tsup src/index.ts --format cjs,esm --dts",
-        "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+        "build": "npm run clean && tsup src/index.ts --format cjs,esm && tsc --emitDeclarationOnly --declaration --project tsconfig.json",
+        "dev": "tsc -b . --watch",
         "test": "vitest",
         "test:run": "vitest run",
         "test:coverage": "vitest run --coverage",
         "lint": "eslint .",
         "format": "prettier --write .",
-        "format:check": "prettier --check ."
+        "format:check": "prettier --check .",
+        "clean": "rm -rf ./dist && rm -f ./tsconfig.tsbuildinfo"
     },
     "keywords": [
         "ragbits",

package/dist/index.d.cts

@@ -1,257 +0,0 @@
-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;
-}
-
-/**
- * Client for communicating with the Ragbits API
- */
-declare class RagbitsClient {
-    private readonly baseUrl;
-    /**
-     * @param config - Configuration object
-     */
-    constructor(config?: ClientConfig);
-    /**
-     * Get the base URL used by this client
-     */
-    getBaseUrl(): string;
-    /**
-     * Build full API URL from path
-     * @private
-     */
-    private _buildApiUrl;
-    /**
-     * Make a request to the API
-     * @private
-     */
-    private _makeRequest;
-    /**
-     * Method to make API requests to known endpoints only
-     * @param endpoint - API endpoint path (must be predefined)
-     * @param options - Typed request options for the specific endpoint
-     */
-    makeRequest<T extends ApiEndpointPath>(endpoint: T, options?: TypedApiRequestOptions<T>): Promise<ApiEndpointResponse<T>>;
-    /**
-     * Method for streaming requests to known endpoints only
-     * @param endpoint - Streaming endpoint path (must be predefined)
-     * @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 };

package/eslint.config.js

@@ -1,21 +0,0 @@
-import js from '@eslint/js'
-import globals from 'globals'
-import tseslint from 'typescript-eslint'
-
-export default tseslint.config(
-    { ignores: ['dist', 'coverage'] },
-    {
-        extends: [js.configs.recommended, ...tseslint.configs.recommended],
-        files: ['**/*.{ts,tsx}'],
-        languageOptions: {
-            ecmaVersion: 2020,
-            globals: globals.node,
-        },
-        rules: {
-            '@typescript-eslint/no-unused-vars': [
-                'error',
-                { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
-            ],
-        },
-    }
-)

package/prettier.config.js

@@ -1,6 +0,0 @@
-export default {
-    trailingComma: 'es5',
-    tabWidth: 4,
-    semi: false,
-    singleQuote: true,
-}