@ragbits/api-client 0.0.1 → 0.0.3

package/dist/index.js

@@ -0,0 +1,189 @@
+// 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";
+  ChatResponseType2["LIVE_UPDATE"] = "live_update";
+  ChatResponseType2["FOLLOWUP_MESSAGES"] = "followup_messages";
+  return ChatResponseType2;
+})(ChatResponseType || {});
+var FeedbackType = /* @__PURE__ */ ((FeedbackType2) => {
+  FeedbackType2["LIKE"] = "like";
+  FeedbackType2["DISLIKE"] = "dislike";
+  return FeedbackType2;
+})(FeedbackType || {});
+var LiveUpdateType = /* @__PURE__ */ ((LiveUpdateType2) => {
+  LiveUpdateType2["START"] = "START";
+  LiveUpdateType2["FINISH"] = "FINISH";
+  return LiveUpdateType2;
+})(LiveUpdateType || {});
+
+// src/index.ts
+var RagbitsClient = class {
+  /**
+   * @param config - Configuration object
+   */
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || "http://127.0.0.1:8000";
+    try {
+      new URL(this.baseUrl);
+    } catch {
+      throw new Error(
+        `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
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Build full API URL from path
+   * @private
+   */
+  _buildApiUrl(path) {
+    return `${this.baseUrl}${path}`;
+  }
+  /**
+   * Make a request to the API
+   * @private
+   */
+  async _makeRequest(url, options = {}) {
+    const defaultOptions = {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+    const response = await fetch(url, { ...defaultOptions, ...options });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return response;
+  }
+  /**
+   * 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
+   */
+  async makeRequest(endpoint, options) {
+    const {
+      method = "GET",
+      body,
+      headers = {},
+      ...restOptions
+    } = options || {};
+    const requestOptions = {
+      method,
+      headers,
+      ...restOptions
+      // This will include signal and other fetch options
+    };
+    if (body && method !== "GET") {
+      requestOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+    }
+    const response = await this._makeRequest(
+      this._buildApiUrl(endpoint),
+      requestOptions
+    );
+    return response.json();
+  }
+  /**
+   * 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(endpoint, data, callbacks, signal) {
+    let isCancelled = false;
+    const processStream = async (response) => {
+      const reader = response.body?.pipeThrough(new TextDecoderStream()).getReader();
+      if (!reader) {
+        throw new Error("Response body is null");
+      }
+      while (!isCancelled && !signal?.aborted) {
+        try {
+          const { value, done } = await reader.read();
+          if (done) {
+            callbacks.onClose?.();
+            break;
+          }
+          const lines = value.split("\n");
+          for (const line of lines) {
+            if (!line.startsWith("data: ")) continue;
+            try {
+              const jsonString = line.replace("data: ", "").trim();
+              const parsedData = JSON.parse(
+                jsonString
+              );
+              await callbacks.onMessage(parsedData);
+            } catch (parseError) {
+              console.error("Error parsing JSON:", parseError);
+              await callbacks.onError(
+                new Error("Error processing server response")
+              );
+            }
+          }
+        } catch (streamError) {
+          console.error("Stream error:", streamError);
+          await callbacks.onError(new Error("Error reading stream"));
+          break;
+        }
+      }
+    };
+    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
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        await processStream(response);
+      } catch (error) {
+        if (signal?.aborted) {
+          return;
+        }
+        console.error("Request error:", error);
+        const errorMessage = error instanceof Error ? error.message : "Error connecting to server";
+        await callbacks.onError(new Error(errorMessage));
+      }
+    };
+    try {
+      startStream();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Failed to start stream";
+      callbacks.onError(new Error(errorMessage));
+    }
+    return () => {
+      isCancelled = true;
+    };
+  }
+};
+export {
+  ChatResponseType,
+  FeedbackType,
+  LiveUpdateType,
+  MessageRole,
+  RagbitsClient
+};

package/dist/types.d.ts

@@ -0,0 +1,238 @@
+import { RJSFSchema } from '@rjsf/utils';
+/**
+ * Message roles for chat conversations
+ */
+export declare enum MessageRole {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system"
+}
+/**
+ * Message structure for chat conversations
+ */
+export interface Message {
+    role: MessageRole;
+    content: string;
+    id?: string;
+}
+/**
+ * Reference structure for document references
+ */
+export interface Reference {
+    title: string;
+    content: string;
+    url?: string;
+}
+/**
+ * Response types from the API
+ */
+export declare enum ChatResponseType {
+    MESSAGE = "message",
+    REFERENCE = "reference",
+    STATE_UPDATE = "state_update",
+    TEXT = "text",
+    MESSAGE_ID = "message_id",
+    CONVERSATION_ID = "conversation_id",
+    LIVE_UPDATE = "live_update",
+    FOLLOWUP_MESSAGES = "followup_messages"
+}
+/**
+ * Feedback types for user feedback
+ */
+export declare enum FeedbackType {
+    LIKE = "like",
+    DISLIKE = "dislike"
+}
+/**
+ * Server state interface for state updates
+ */
+export interface ServerState {
+    state: Record<string, unknown>;
+    signature: string;
+}
+export declare enum LiveUpdateType {
+    START = "START",
+    FINISH = "FINISH"
+}
+export interface LiveUpdate {
+    update_id: string;
+    type: LiveUpdateType;
+    content: {
+        label: string;
+        description?: 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;
+}
+interface LiveUpdateChatResponse {
+    type: ChatResponseType.LIVE_UPDATE;
+    content: LiveUpdate;
+}
+interface FollowupMessagesChatResponse {
+    type: ChatResponseType.FOLLOWUP_MESSAGES;
+    content: string[];
+}
+/**
+ * Typed chat response union
+ */
+export type TypedChatResponse = TextChatResponse | ReferenceChatResponse | MessageIdChatResponse | ConversationIdChatResponse | StateUpdateChatResponse | LiveUpdateChatResponse | FollowupMessagesChatResponse;
+/**
+ * Base chat request to the API
+ */
+export interface ChatRequest {
+    message: string;
+    history: Message[];
+    context?: Record<string, unknown>;
+}
+/**
+ * Feedback request to the API
+ */
+export interface FeedbackRequest {
+    message_id: string;
+    feedback: FeedbackType;
+    payload: Record<string, unknown> | null;
+}
+/**
+ * Feedback response from the API
+ */
+export interface FeedbackResponse {
+    status: string;
+}
+/**
+ * UI customization configuration
+ */
+export interface UICustomization {
+    header: {
+        title?: string;
+        subtitle?: string;
+        logo?: string;
+    };
+    welcome_message?: string;
+}
+/**
+ * Configuration response from the API
+ */
+export interface ConfigResponse {
+    feedback: {
+        like: {
+            enabled: boolean;
+            form: RJSFSchema | null;
+        };
+        dislike: {
+            enabled: boolean;
+            form: RJSFSchema | null;
+        };
+    };
+    customization: UICustomization | null;
+}
+/**
+ * Configuration for the client
+ */
+export interface ClientConfig {
+    baseUrl?: string;
+}
+/**
+ * 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>;
+}
+/**
+ * Regular API endpoint definitions with their request/response types
+ */
+export 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
+ */
+export interface StreamingEndpoints {
+    '/api/chat': {
+        method: 'POST';
+        request: ChatRequest;
+        stream: TypedChatResponse;
+    };
+}
+/**
+ * Extract endpoint paths as a union type
+ */
+export type ApiEndpointPath = keyof ApiEndpoints;
+/**
+ * Extract streaming endpoint paths as a union type
+ */
+export type StreamingEndpointPath = keyof StreamingEndpoints;
+/**
+ * Extract request type for a specific API endpoint
+ */
+export type ApiEndpointRequest<T extends ApiEndpointPath> = ApiEndpoints[T]['request'];
+/**
+ * Extract response type for a specific API endpoint
+ */
+export type ApiEndpointResponse<T extends ApiEndpointPath> = ApiEndpoints[T]['response'];
+/**
+ * Extract HTTP method for a specific API endpoint
+ */
+export type ApiEndpointMethod<T extends ApiEndpointPath> = ApiEndpoints[T]['method'];
+/**
+ * Extract request type for a specific streaming endpoint
+ */
+export type StreamingEndpointRequest<T extends StreamingEndpointPath> = StreamingEndpoints[T]['request'];
+/**
+ * Extract stream response type for a specific streaming endpoint
+ */
+export type StreamingEndpointStream<T extends StreamingEndpointPath> = StreamingEndpoints[T]['stream'];
+/**
+ * Extract HTTP method for a specific streaming endpoint
+ */
+export type StreamingEndpointMethod<T extends StreamingEndpointPath> = StreamingEndpoints[T]['method'];
+/**
+ * Generic request options for API endpoints with typed methods and body
+ */
+export 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
+ */
+export interface TypedStreamRequestOptions<T extends StreamingEndpointPath> {
+    method?: StreamingEndpointMethod<T>;
+    body?: StreamingEndpointRequest<T>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ragbits/api-client",
-    "version": "0.0.1",
+    "version": "0.0.3",
     "description": "JavaScript client for the Ragbits API",
     "main": "dist/index.cjs",
     "module": "dist/index.js",
@@ -14,14 +14,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"
     },
     "keywords": [
         "ragbits",

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,
-}

package/src/index.ts

@@ -1,213 +0,0 @@
-import type {
-    ClientConfig,
-    StreamCallbacks,
-    ApiEndpointPath,
-    ApiEndpointResponse,
-    TypedApiRequestOptions,
-    StreamingEndpointPath,
-    StreamingEndpointRequest,
-    StreamingEndpointStream,
-} from './types'
-
-/**
- * Client for communicating with the Ragbits API
- */
-export class RagbitsClient {
-    private readonly baseUrl: string
-
-    /**
-     * @param config - Configuration object
-     */
-    constructor(config: ClientConfig = {}) {
-        this.baseUrl = config.baseUrl || 'http://127.0.0.1:8000'
-
-        // Validate the base URL
-        try {
-            new URL(this.baseUrl)
-        } catch {
-            throw new Error(
-                `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
-     */
-    getBaseUrl(): string {
-        return this.baseUrl
-    }
-
-    /**
-     * Build full API URL from path
-     * @private
-     */
-    private _buildApiUrl(path: string): string {
-        return `${this.baseUrl}${path}`
-    }
-
-    /**
-     * Make a request to the API
-     * @private
-     */
-    private async _makeRequest(
-        url: string,
-        options: RequestInit = {}
-    ): Promise<Response> {
-        const defaultOptions: RequestInit = {
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        }
-
-        const response = await fetch(url, { ...defaultOptions, ...options })
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`)
-        }
-        return response
-    }
-
-    /**
-     * 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
-     */
-    async makeRequest<T extends ApiEndpointPath>(
-        endpoint: T,
-        options?: TypedApiRequestOptions<T>
-    ): Promise<ApiEndpointResponse<T>> {
-        const {
-            method = 'GET',
-            body,
-            headers = {},
-            ...restOptions
-        } = options || {}
-
-        const requestOptions: RequestInit = {
-            method,
-            headers,
-            ...restOptions, // This will include signal and other fetch options
-        }
-
-        if (body && method !== 'GET') {
-            requestOptions.body =
-                typeof body === 'string' ? body : JSON.stringify(body)
-        }
-
-        const response = await this._makeRequest(
-            this._buildApiUrl(endpoint),
-            requestOptions
-        )
-        return response.json()
-    }
-
-    /**
-     * 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 {
-        let isCancelled = false
-
-        const processStream = async (response: Response): Promise<void> => {
-            const reader = response.body
-                ?.pipeThrough(new TextDecoderStream())
-                .getReader()
-
-            if (!reader) {
-                throw new Error('Response body is null')
-            }
-
-            while (!isCancelled && !signal?.aborted) {
-                try {
-                    const { value, done } = await reader.read()
-                    if (done) {
-                        callbacks.onClose?.()
-                        break
-                    }
-
-                    const lines = value.split('\n')
-                    for (const line of lines) {
-                        if (!line.startsWith('data: ')) continue
-
-                        try {
-                            const jsonString = line.replace('data: ', '').trim()
-                            const parsedData = JSON.parse(
-                                jsonString
-                            ) as StreamingEndpointStream<T>
-                            await callbacks.onMessage(parsedData)
-                        } catch (parseError) {
-                            console.error('Error parsing JSON:', parseError)
-                            await callbacks.onError(
-                                new Error('Error processing server response')
-                            )
-                        }
-                    }
-                } catch (streamError) {
-                    console.error('Stream error:', streamError)
-                    await callbacks.onError(new Error('Error reading stream'))
-                    break
-                }
-            }
-        }
-
-        const startStream = async (): Promise<void> => {
-            try {
-                const response = await fetch(this._buildApiUrl(endpoint), {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Accept: 'text/event-stream',
-                    },
-                    body: JSON.stringify(data),
-                    signal,
-                })
-
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`)
-                }
-
-                await processStream(response)
-            } catch (error) {
-                if (signal?.aborted) {
-                    return
-                }
-
-                console.error('Request error:', error)
-                const errorMessage =
-                    error instanceof Error
-                        ? error.message
-                        : 'Error connecting to server'
-                await callbacks.onError(new Error(errorMessage))
-            }
-        }
-
-        try {
-            startStream()
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error
-                    ? error.message
-                    : 'Failed to start stream'
-            callbacks.onError(new Error(errorMessage))
-        }
-
-        return () => {
-            isCancelled = true
-        }
-    }
-}
-
-// Re-export types
-export * from './types'