@ragbits/api-client 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -0,0 +1,211 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChatResponseType: () => ChatResponseType,
+  FeedbackType: () => FeedbackType,
+  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/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;
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatResponseType,
+  FeedbackType,
+  MessageRole,
+  RagbitsClient
+});

package/dist/index.d.cts

@@ -0,0 +1,257 @@
+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/dist/index.d.ts

@@ -0,0 +1,257 @@
+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/dist/index.js

@@ -0,0 +1,181 @@
+// 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/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,
+  MessageRole,
+  RagbitsClient
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ragbits/api-client",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "description": "JavaScript client for the Ragbits API",
     "main": "dist/index.cjs",
     "module": "dist/index.js",