openrag-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,696 @@
+// src/chat.ts
+var ChatStream = class {
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+  }
+  _text = "";
+  _chatId = null;
+  _sources = [];
+  _consumed = false;
+  _reader = null;
+  _response = null;
+  /** The accumulated text from content events. */
+  get text() {
+    return this._text;
+  }
+  /** The chat ID for continuing the conversation. */
+  get chatId() {
+    return this._chatId;
+  }
+  /** The sources retrieved during the conversation. */
+  get sources() {
+    return this._sources;
+  }
+  /** @internal Initialize the stream. */
+  async _init() {
+    const body = {
+      message: this.options.message,
+      stream: true,
+      limit: this.options.limit ?? 10,
+      score_threshold: this.options.scoreThreshold ?? 0
+    };
+    if (this.options.chatId) {
+      body["chat_id"] = this.options.chatId;
+    }
+    if (this.options.filters) {
+      body["filters"] = this.options.filters;
+    }
+    if (this.options.filterId) {
+      body["filter_id"] = this.options.filterId;
+    }
+    this._response = await this.client._request("POST", "/api/v1/chat", {
+      body: JSON.stringify(body),
+      stream: true
+    });
+    if (!this._response.body) {
+      throw new Error("Response body is null");
+    }
+    this._reader = this._response.body.getReader();
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this._consumed) {
+      throw new Error("Stream has already been consumed");
+    }
+    this._consumed = true;
+    if (!this._reader) {
+      throw new Error("Stream not initialized");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await this._reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data:")) continue;
+        const dataStr = trimmed.slice(5).trim();
+        if (!dataStr) continue;
+        try {
+          const data = JSON.parse(dataStr);
+          const eventType = data.type;
+          if (eventType === "content") {
+            const delta = data.delta || "";
+            this._text += delta;
+            yield { type: "content", delta };
+          } else if (eventType === "sources") {
+            this._sources = data.sources || [];
+            yield { type: "sources", sources: this._sources };
+          } else if (eventType === "done") {
+            this._chatId = data.chat_id || null;
+            yield { type: "done", chatId: this._chatId };
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Iterate over just the text deltas.
+   */
+  get textStream() {
+    const self = this;
+    return {
+      async *[Symbol.asyncIterator]() {
+        for await (const event of self) {
+          if (event.type === "content") {
+            yield event.delta;
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Consume the stream and return the complete text.
+   */
+  async finalText() {
+    for await (const _ of this) {
+    }
+    return this._text;
+  }
+  /** Clean up resources. */
+  [Symbol.dispose]() {
+    this._reader?.cancel().catch(() => {
+    });
+  }
+  /** Close the stream. */
+  close() {
+    this[Symbol.dispose]();
+  }
+};
+var ChatClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Send a chat message.
+   *
+   * @param options - Chat options including message, stream flag, etc.
+   * @returns ChatResponse if stream=false, AsyncIterable<StreamEvent> if stream=true.
+   */
+  async create(options) {
+    if (options.stream) {
+      return this._createStreamingIterator(options);
+    }
+    return this._createNonStreaming(options);
+  }
+  async _createNonStreaming(options) {
+    const body = {
+      message: options.message,
+      stream: false,
+      limit: options.limit ?? 10,
+      score_threshold: options.scoreThreshold ?? 0
+    };
+    if (options.chatId) {
+      body["chat_id"] = options.chatId;
+    }
+    if (options.filters) {
+      body["filters"] = options.filters;
+    }
+    if (options.filterId) {
+      body["filter_id"] = options.filterId;
+    }
+    const response = await this.client._request("POST", "/api/v1/chat", {
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    return {
+      response: data.response || "",
+      chatId: data.chat_id || null,
+      sources: data.sources || []
+    };
+  }
+  async _createStreamingIterator(options) {
+    const stream = new ChatStream(this.client, options);
+    await stream._init();
+    return stream;
+  }
+  /**
+   * Create a streaming chat context manager.
+   *
+   * @param options - Chat options.
+   * @returns ChatStream with helpers.
+   */
+  async stream(options) {
+    const stream = new ChatStream(this.client, { ...options, stream: true });
+    await stream._init();
+    return stream;
+  }
+  /**
+   * List all conversations.
+   */
+  async list() {
+    const response = await this.client._request("GET", "/api/v1/chat");
+    const data = await response.json();
+    const conversations = (data.conversations || []).map(
+      (c) => ({
+        chatId: c["chat_id"],
+        title: c["title"] || "",
+        createdAt: c["created_at"] || null,
+        lastActivity: c["last_activity"] || null,
+        messageCount: c["message_count"] || 0
+      })
+    );
+    return { conversations };
+  }
+  /**
+   * Get a specific conversation with full message history.
+   *
+   * @param chatId - The ID of the conversation to retrieve.
+   */
+  async get(chatId) {
+    const response = await this.client._request("GET", `/api/v1/chat/${chatId}`);
+    const data = await response.json();
+    const messages = (data.messages || []).map(
+      (m) => ({
+        role: m["role"],
+        content: m["content"],
+        timestamp: m["timestamp"] || null
+      })
+    );
+    return {
+      chatId: data.chat_id || chatId,
+      title: data.title || "",
+      createdAt: data.created_at || null,
+      lastActivity: data.last_activity || null,
+      messageCount: messages.length,
+      messages
+    };
+  }
+  /**
+   * Delete a conversation.
+   *
+   * @param chatId - The ID of the conversation to delete.
+   */
+  async delete(chatId) {
+    const response = await this.client._request("DELETE", `/api/v1/chat/${chatId}`);
+    const data = await response.json();
+    return data.success ?? false;
+  }
+};
+
+// src/documents.ts
+var DocumentsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Ingest a document into the knowledge base.
+   *
+   * @param options - Ingest options (filePath or file+filename).
+   * @returns IngestTaskStatus with final status if wait=true, IngestResponse with task_id if wait=false.
+   */
+  async ingest(options) {
+    const formData = new FormData();
+    const wait = options.wait ?? true;
+    const pollInterval = options.pollInterval ?? 1;
+    const timeout = options.timeout ?? 300;
+    if (options.filePath) {
+      if (typeof globalThis.process !== "undefined") {
+        const fs = await import('fs');
+        const path = await import('path');
+        const fileBuffer = fs.readFileSync(options.filePath);
+        const filename = path.basename(options.filePath);
+        const blob = new Blob([fileBuffer]);
+        formData.append("file", blob, filename);
+      } else {
+        throw new Error("filePath is only supported in Node.js");
+      }
+    } else if (options.file) {
+      if (!options.filename) {
+        throw new Error("filename is required when providing file");
+      }
+      formData.append("file", options.file, options.filename);
+    } else {
+      throw new Error("Either filePath or file must be provided");
+    }
+    const response = await this.client._request(
+      "POST",
+      "/api/v1/documents/ingest",
+      {
+        body: formData,
+        isMultipart: true
+      }
+    );
+    const data = await response.json();
+    const ingestResponse = {
+      task_id: data.task_id,
+      status: data.status ?? null,
+      filename: data.filename ?? null
+    };
+    if (!wait) {
+      return ingestResponse;
+    }
+    return await this.waitForTask(ingestResponse.task_id, pollInterval, timeout);
+  }
+  /**
+   * Get the status of an ingestion task.
+   *
+   * @param taskId - The task ID returned from ingest().
+   * @returns IngestTaskStatus with current task status.
+   */
+  async getTaskStatus(taskId) {
+    const response = await this.client._request(
+      "GET",
+      `/api/v1/tasks/${taskId}`
+    );
+    const data = await response.json();
+    return {
+      task_id: data.task_id,
+      status: data.status,
+      total_files: data.total_files ?? 0,
+      processed_files: data.processed_files ?? 0,
+      successful_files: data.successful_files ?? 0,
+      failed_files: data.failed_files ?? 0,
+      files: data.files ?? {}
+    };
+  }
+  /**
+   * Wait for an ingestion task to complete.
+   *
+   * @param taskId - The task ID to wait for.
+   * @param pollInterval - Seconds between status checks.
+   * @param timeout - Maximum seconds to wait.
+   * @returns IngestTaskStatus with final status.
+   */
+  async waitForTask(taskId, pollInterval = 1, timeout = 300) {
+    const startTime = Date.now();
+    const timeoutMs = timeout * 1e3;
+    while (Date.now() - startTime < timeoutMs) {
+      const status = await this.getTaskStatus(taskId);
+      if (status.status === "completed" || status.status === "failed") {
+        return status;
+      }
+      await this.sleep(pollInterval * 1e3);
+    }
+    throw new Error(
+      `Ingestion task ${taskId} did not complete within ${timeout}s`
+    );
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Delete a document from the knowledge base.
+   *
+   * @param filename - Name of the file to delete.
+   * @returns DeleteDocumentResponse with deleted chunk count.
+   */
+  async delete(filename) {
+    const response = await this.client._request("DELETE", "/api/v1/documents", {
+      body: JSON.stringify({ filename })
+    });
+    const data = await response.json();
+    return {
+      success: data.success ?? false,
+      deleted_chunks: data.deleted_chunks ?? 0
+    };
+  }
+};
+
+// src/search.ts
+var SearchClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Perform semantic search on documents.
+   *
+   * @param query - The search query text.
+   * @param options - Optional search options.
+   * @returns SearchResponse containing the search results.
+   */
+  async query(query, options) {
+    const body = {
+      query,
+      limit: options?.limit ?? 10,
+      score_threshold: options?.scoreThreshold ?? 0
+    };
+    if (options?.filters) {
+      body["filters"] = options.filters;
+    }
+    if (options?.filterId) {
+      body["filter_id"] = options.filterId;
+    }
+    const response = await this.client._request("POST", "/api/v1/search", {
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    return {
+      results: data.results || []
+    };
+  }
+};
+
+// src/knowledge-filters.ts
+var KnowledgeFiltersClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new knowledge filter.
+   *
+   * @param options - The filter options including name and queryData.
+   * @returns The created filter response with ID.
+   */
+  async create(options) {
+    const body = {
+      name: options.name,
+      description: options.description ?? "",
+      queryData: JSON.stringify(options.queryData)
+    };
+    const response = await this.client._request("POST", "/knowledge-filter", {
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    return {
+      success: data.success ?? false,
+      id: data.id,
+      error: data.error
+    };
+  }
+  /**
+   * Search for knowledge filters by name, description, or query content.
+   *
+   * @param query - Optional search query text.
+   * @param limit - Maximum number of results (default 20).
+   * @returns List of matching knowledge filters.
+   */
+  async search(query, limit) {
+    const body = {
+      query: query ?? "",
+      limit: limit ?? 20
+    };
+    const response = await this.client._request(
+      "POST",
+      "/knowledge-filter/search",
+      {
+        body: JSON.stringify(body)
+      }
+    );
+    const data = await response.json();
+    if (!data.success || !data.filters) {
+      return [];
+    }
+    return data.filters.map((f) => this._parseFilter(f));
+  }
+  /**
+   * Get a specific knowledge filter by ID.
+   *
+   * @param filterId - The ID of the filter to retrieve.
+   * @returns The knowledge filter or null if not found.
+   */
+  async get(filterId) {
+    try {
+      const response = await this.client._request(
+        "GET",
+        `/knowledge-filter/${filterId}`
+      );
+      const data = await response.json();
+      if (!data.success || !data.filter) {
+        return null;
+      }
+      return this._parseFilter(data.filter);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Update an existing knowledge filter.
+   *
+   * @param filterId - The ID of the filter to update.
+   * @param options - The fields to update.
+   * @returns Success status.
+   */
+  async update(filterId, options) {
+    const body = {};
+    if (options.name !== void 0) {
+      body["name"] = options.name;
+    }
+    if (options.description !== void 0) {
+      body["description"] = options.description;
+    }
+    if (options.queryData !== void 0) {
+      body["queryData"] = JSON.stringify(options.queryData);
+    }
+    const response = await this.client._request(
+      "PUT",
+      `/knowledge-filter/${filterId}`,
+      {
+        body: JSON.stringify(body)
+      }
+    );
+    const data = await response.json();
+    return data.success ?? false;
+  }
+  /**
+   * Delete a knowledge filter.
+   *
+   * @param filterId - The ID of the filter to delete.
+   * @returns Success status.
+   */
+  async delete(filterId) {
+    const response = await this.client._request(
+      "DELETE",
+      `/knowledge-filter/${filterId}`
+    );
+    const data = await response.json();
+    return data.success ?? false;
+  }
+  /**
+   * Parse a filter from API response, handling JSON-stringified queryData.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _parseFilter(filter) {
+    let queryData = filter["query_data"] ?? filter["queryData"];
+    if (typeof queryData === "string") {
+      try {
+        queryData = JSON.parse(queryData);
+      } catch {
+        queryData = {};
+      }
+    }
+    return {
+      id: filter["id"],
+      name: filter["name"],
+      description: filter["description"],
+      queryData,
+      owner: filter["owner"],
+      createdAt: filter["created_at"] ?? filter["createdAt"],
+      updatedAt: filter["updated_at"] ?? filter["updatedAt"]
+    };
+  }
+};
+
+// src/types.ts
+var OpenRAGError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "OpenRAGError";
+  }
+};
+var AuthenticationError = class extends OpenRAGError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "AuthenticationError";
+  }
+};
+var NotFoundError = class extends OpenRAGError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends OpenRAGError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends OpenRAGError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "RateLimitError";
+  }
+};
+var ServerError = class extends OpenRAGError {
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "ServerError";
+  }
+};
+
+// src/client.ts
+function getEnv(key) {
+  if (typeof globalThis.process !== "undefined" && globalThis.process.env) {
+    return globalThis.process.env[key];
+  }
+  return void 0;
+}
+var SettingsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get current OpenRAG configuration.
+   */
+  async get() {
+    const response = await this.client._request("GET", "/api/v1/settings");
+    const data = await response.json();
+    return {
+      agent: data.agent || {},
+      knowledge: data.knowledge || {}
+    };
+  }
+  /**
+   * Update OpenRAG configuration.
+   *
+   * @param options - The settings to update.
+   * @returns Success response with message.
+   */
+  async update(options) {
+    const response = await this.client._request("POST", "/settings", {
+      body: JSON.stringify(options)
+    });
+    const data = await response.json();
+    return {
+      message: data.message || "Settings updated"
+    };
+  }
+};
+var OpenRAGClient = class _OpenRAGClient {
+  static DEFAULT_BASE_URL = "http://localhost:8080";
+  _apiKey;
+  _baseUrl;
+  _timeout;
+  /** Chat client for conversations. */
+  chat;
+  /** Search client for semantic search. */
+  search;
+  /** Documents client for ingestion and deletion. */
+  documents;
+  /** Settings client for configuration. */
+  settings;
+  /** Knowledge filters client for managing filters. */
+  knowledgeFilters;
+  constructor(options = {}) {
+    this._apiKey = options.apiKey || getEnv("OPENRAG_API_KEY") || "";
+    if (!this._apiKey) {
+      throw new AuthenticationError(
+        "API key is required. Set OPENRAG_API_KEY environment variable or pass apiKey option."
+      );
+    }
+    this._baseUrl = (options.baseUrl || getEnv("OPENRAG_URL") || _OpenRAGClient.DEFAULT_BASE_URL).replace(/\/$/, "");
+    this._timeout = options.timeout ?? 3e4;
+    this.chat = new ChatClient(this);
+    this.search = new SearchClient(this);
+    this.documents = new DocumentsClient(this);
+    this.settings = new SettingsClient(this);
+    this.knowledgeFilters = new KnowledgeFiltersClient(this);
+  }
+  /** @internal Get request headers with authentication. */
+  _getHeaders(isMultipart = false) {
+    const headers = {
+      "X-API-Key": this._apiKey
+    };
+    if (!isMultipart) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  /** @internal Make an authenticated request to the API. */
+  async _request(method, path, options = {}) {
+    const url = `${this._baseUrl}${path}`;
+    const headers = this._getHeaders(options.isMultipart);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this._timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: options.body ?? null,
+        signal: controller.signal
+      });
+      if (!options.stream) {
+        this._handleError(response);
+      }
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /** @internal Handle error responses. */
+  _handleError(response) {
+    if (response.ok) return;
+    const statusCode = response.status;
+    const errorMessages = {
+      401: "Invalid or missing API key",
+      403: "Access denied",
+      404: "Resource not found",
+      400: "Invalid request",
+      429: "Rate limit exceeded"
+    };
+    const message = errorMessages[statusCode] || `HTTP ${statusCode}`;
+    if (statusCode === 401 || statusCode === 403) {
+      throw new AuthenticationError(message, statusCode);
+    } else if (statusCode === 404) {
+      throw new NotFoundError(message, statusCode);
+    } else if (statusCode === 400) {
+      throw new ValidationError(message, statusCode);
+    } else if (statusCode === 429) {
+      throw new RateLimitError(message, statusCode);
+    } else if (statusCode >= 500) {
+      throw new ServerError(message, statusCode);
+    } else {
+      throw new OpenRAGError(message, statusCode);
+    }
+  }
+};
+
+export { AuthenticationError, ChatClient, ChatStream, DocumentsClient, KnowledgeFiltersClient, NotFoundError, OpenRAGClient, OpenRAGError, RateLimitError, SearchClient, ServerError, ValidationError };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map