@ragbits/api-client 0.0.2 → 0.0.3

package/dist/{index.d.cts → types.d.ts}

@@ -1,9 +1,8 @@
 import { RJSFSchema } from '@rjsf/utils';
-
 /**
  * Message roles for chat conversations
  */
-declare enum MessageRole {
+export declare enum MessageRole {
     USER = "user",
     ASSISTANT = "assistant",
     SYSTEM = "system"
@@ -11,7 +10,7 @@ declare enum MessageRole {
 /**
  * Message structure for chat conversations
  */
-interface Message {
+export interface Message {
     role: MessageRole;
     content: string;
     id?: string;
@@ -19,7 +18,7 @@ interface Message {
 /**
  * Reference structure for document references
  */
-interface Reference {
+export interface Reference {
     title: string;
     content: string;
     url?: string;
@@ -27,28 +26,42 @@ interface Reference {
 /**
  * Response types from the API
  */
-declare enum ChatResponseType {
+export declare enum ChatResponseType {
     MESSAGE = "message",
     REFERENCE = "reference",
     STATE_UPDATE = "state_update",
     TEXT = "text",
     MESSAGE_ID = "message_id",
-    CONVERSATION_ID = "conversation_id"
+    CONVERSATION_ID = "conversation_id",
+    LIVE_UPDATE = "live_update",
+    FOLLOWUP_MESSAGES = "followup_messages"
 }
 /**
  * Feedback types for user feedback
  */
-declare enum FeedbackType {
+export declare enum FeedbackType {
     LIKE = "like",
     DISLIKE = "dislike"
 }
 /**
  * Server state interface for state updates
  */
-interface ServerState {
+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
  */
@@ -72,14 +85,22 @@ 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
  */
-type TypedChatResponse = TextChatResponse | ReferenceChatResponse | MessageIdChatResponse | ConversationIdChatResponse | StateUpdateChatResponse;
+export type TypedChatResponse = TextChatResponse | ReferenceChatResponse | MessageIdChatResponse | ConversationIdChatResponse | StateUpdateChatResponse | LiveUpdateChatResponse | FollowupMessagesChatResponse;
 /**
  * Base chat request to the API
  */
-interface ChatRequest {
+export interface ChatRequest {
     message: string;
     history: Message[];
     context?: Record<string, unknown>;
@@ -87,7 +108,7 @@ interface ChatRequest {
 /**
  * Feedback request to the API
  */
-interface FeedbackRequest {
+export interface FeedbackRequest {
     message_id: string;
     feedback: FeedbackType;
     payload: Record<string, unknown> | null;
@@ -95,13 +116,13 @@ interface FeedbackRequest {
 /**
  * Feedback response from the API
  */
-interface FeedbackResponse {
+export interface FeedbackResponse {
     status: string;
 }
 /**
  * UI customization configuration
  */
-interface UICustomization {
+export interface UICustomization {
     header: {
         title?: string;
         subtitle?: string;
@@ -112,7 +133,7 @@ interface UICustomization {
 /**
  * Configuration response from the API
  */
-interface ConfigResponse {
+export interface ConfigResponse {
     feedback: {
         like: {
             enabled: boolean;
@@ -128,13 +149,13 @@ interface ConfigResponse {
 /**
  * Configuration for the client
  */
-interface ClientConfig {
+export interface ClientConfig {
     baseUrl?: string;
 }
 /**
  * Callbacks for handling streaming responses
  */
-interface StreamCallbacks<T, E = Error> {
+export interface StreamCallbacks<T, E = Error> {
     onMessage: (data: T) => void | Promise<void>;
     onError: (error: E) => void | Promise<void>;
     onClose?: () => void | Promise<void>;
@@ -142,7 +163,7 @@ interface StreamCallbacks<T, E = Error> {
 /**
  * Regular API endpoint definitions with their request/response types
  */
-interface ApiEndpoints {
+export interface ApiEndpoints {
     '/api/config': {
         method: 'GET';
         request: never;
@@ -157,7 +178,7 @@ interface ApiEndpoints {
 /**
  * Streaming API endpoint definitions with their request/stream response types
  */
-interface StreamingEndpoints {
+export interface StreamingEndpoints {
     '/api/chat': {
         method: 'POST';
         request: ChatRequest;
@@ -167,39 +188,39 @@ interface StreamingEndpoints {
 /**
  * Extract endpoint paths as a union type
  */
-type ApiEndpointPath = keyof ApiEndpoints;
+export type ApiEndpointPath = keyof ApiEndpoints;
 /**
  * Extract streaming endpoint paths as a union type
  */
-type StreamingEndpointPath = keyof StreamingEndpoints;
+export type StreamingEndpointPath = keyof StreamingEndpoints;
 /**
  * Extract request type for a specific API endpoint
  */
-type ApiEndpointRequest<T extends ApiEndpointPath> = ApiEndpoints[T]['request'];
+export type ApiEndpointRequest<T extends ApiEndpointPath> = ApiEndpoints[T]['request'];
 /**
  * Extract response type for a specific API endpoint
  */
-type ApiEndpointResponse<T extends ApiEndpointPath> = ApiEndpoints[T]['response'];
+export type ApiEndpointResponse<T extends ApiEndpointPath> = ApiEndpoints[T]['response'];
 /**
  * Extract HTTP method for a specific API endpoint
  */
-type ApiEndpointMethod<T extends ApiEndpointPath> = ApiEndpoints[T]['method'];
+export type ApiEndpointMethod<T extends ApiEndpointPath> = ApiEndpoints[T]['method'];
 /**
  * Extract request type for a specific streaming endpoint
  */
-type StreamingEndpointRequest<T extends StreamingEndpointPath> = StreamingEndpoints[T]['request'];
+export 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'];
+export type StreamingEndpointStream<T extends StreamingEndpointPath> = StreamingEndpoints[T]['stream'];
 /**
  * Extract HTTP method for a specific streaming endpoint
  */
-type StreamingEndpointMethod<T extends StreamingEndpointPath> = StreamingEndpoints[T]['method'];
+export type StreamingEndpointMethod<T extends StreamingEndpointPath> = StreamingEndpoints[T]['method'];
 /**
  * Generic request options for API endpoints with typed methods and body
  */
-interface TypedApiRequestOptions<T extends ApiEndpointPath> {
+export interface TypedApiRequestOptions<T extends ApiEndpointPath> {
     method?: ApiEndpointMethod<T>;
     body?: ApiEndpointRequest<T> extends never ? undefined : ApiEndpointRequest<T>;
     headers?: Record<string, string>;
@@ -208,50 +229,10 @@ interface TypedApiRequestOptions<T extends ApiEndpointPath> {
 /**
  * Typed request options for specific streaming endpoints
  */
-interface TypedStreamRequestOptions<T extends StreamingEndpointPath> {
+export 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 };
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ragbits/api-client",
-    "version": "0.0.2",
+    "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'