@aliyun-rds/rag-agent-sdk 0.1.1

package/dist/index.mjs

@@ -0,0 +1,1546 @@
+// src/errors.ts
+var RagAgentError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.name = "RagAgentError";
+    this.statusCode = details?.statusCode;
+    this.response = details?.response;
+    this.errorCode = details?.errorCode;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      statusCode: this.statusCode,
+      response: this.response,
+      errorCode: this.errorCode
+    };
+  }
+};
+var AuthenticationError = class extends RagAgentError {
+  constructor(message = "Authentication failed", response) {
+    super(message, { statusCode: 401, response });
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends RagAgentError {
+  constructor(message = "Permission denied", response) {
+    super(message, { statusCode: 403, response });
+    this.name = "AuthorizationError";
+  }
+};
+var NotFoundError = class extends RagAgentError {
+  constructor(message = "Resource not found", options) {
+    super(message, { statusCode: 404, response: options?.response });
+    this.name = "NotFoundError";
+    this.resourceType = options?.resourceType;
+    this.resourceId = options?.resourceId;
+  }
+};
+var DatasetNotFoundError = class extends NotFoundError {
+  constructor(datasetId, message) {
+    super(message ?? `Dataset not found: ${datasetId}`, {
+      resourceType: "dataset",
+      resourceId: datasetId
+    });
+    this.name = "DatasetNotFoundError";
+    this.datasetId = datasetId;
+  }
+};
+var DocumentNotFoundError = class extends NotFoundError {
+  constructor(docId, datasetId, message) {
+    super(message ?? `Document not found: ${docId}`, {
+      resourceType: "document",
+      resourceId: docId
+    });
+    this.name = "DocumentNotFoundError";
+    this.docId = docId;
+    this.datasetId = datasetId;
+  }
+};
+var ValidationError = class extends RagAgentError {
+  constructor(message = "Validation error", options) {
+    super(message, { statusCode: 400, response: options?.response });
+    this.name = "ValidationError";
+    this.errors = options?.errors;
+  }
+};
+var RateLimitError = class extends RagAgentError {
+  constructor(message = "Rate limit exceeded", options) {
+    super(message, { statusCode: 429, response: options?.response });
+    this.name = "RateLimitError";
+    this.retryAfter = options?.retryAfter;
+  }
+};
+var ServerError = class extends RagAgentError {
+  constructor(message = "Internal server error", statusCode = 500, response) {
+    super(message, { statusCode, response });
+    this.name = "ServerError";
+  }
+};
+var ConnectionError = class extends RagAgentError {
+  constructor(message = "Failed to connect to server", originalError) {
+    super(message);
+    this.name = "ConnectionError";
+    this.originalError = originalError;
+  }
+};
+var TimeoutError = class extends RagAgentError {
+  constructor(message = "Request timed out", timeout) {
+    super(message);
+    this.name = "TimeoutError";
+    this.timeout = timeout;
+  }
+};
+function createErrorFromResponse(statusCode, data) {
+  const message = data.message || data.detail || JSON.stringify(data);
+  switch (statusCode) {
+    case 400:
+      return new ValidationError(message, { response: data });
+    case 401:
+      return new AuthenticationError(message, data);
+    case 403:
+      return new AuthorizationError(message, data);
+    case 404:
+      return new NotFoundError(message, { response: data });
+    case 429:
+      return new RateLimitError(message, { response: data });
+    default:
+      if (statusCode >= 500) {
+        return new ServerError(message, statusCode, data);
+      }
+      return new RagAgentError(message, { statusCode, response: data });
+  }
+}
+
+// src/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+    this.timeout = config.timeout ?? 3e4;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.retryDelay = config.retryDelay ?? 1e3;
+    this.retryMultiplier = config.retryMultiplier ?? 2;
+  }
+  buildUrl(path, params) {
+    const url = path.startsWith("http") ? path : `${this.baseUrl}/${path.replace(/^\//, "")}`;
+    if (!params) return url;
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        searchParams.append(key, String(value));
+      }
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  async handleResponse(response) {
+    let data;
+    try {
+      const text = await response.text();
+      data = text ? JSON.parse(text) : {};
+    } catch {
+      data = { message: await response.text() };
+    }
+    if (response.ok) {
+      return data;
+    }
+    throw createErrorFromResponse(response.status, data);
+  }
+  isRetryable(error) {
+    if (error instanceof RateLimitError || error instanceof ServerError) {
+      return true;
+    }
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      return true;
+    }
+    return false;
+  }
+  async requestWithRetry(options) {
+    const url = this.buildUrl(options.path, options.params);
+    let lastError;
+    let delay = this.retryDelay;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const fetchOptions = {
+          method: options.method,
+          headers: {
+            ...this.defaultHeaders,
+            ...options.headers
+          },
+          signal: controller.signal
+        };
+        if (options.body !== void 0 && options.method !== "GET") {
+          fetchOptions.body = JSON.stringify(options.body);
+        }
+        const response = await fetch(url, fetchOptions);
+        clearTimeout(timeoutId);
+        return await this.handleResponse(response);
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new TimeoutError("Request timed out", this.timeout);
+        } else if (error instanceof RagAgentError) {
+          if (!this.isRetryable(error) || attempt === this.maxRetries) {
+            throw error;
+          }
+          lastError = error;
+          if (error instanceof RateLimitError && error.retryAfter) {
+            delay = error.retryAfter * 1e3;
+          }
+        } else if (error instanceof TypeError) {
+          lastError = new ConnectionError(error.message, error);
+        } else {
+          throw error;
+        }
+        if (attempt < this.maxRetries) {
+          await this.sleep(delay);
+          delay *= this.retryMultiplier;
+        }
+      }
+    }
+    throw lastError ?? new RagAgentError("Request failed after retries");
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async get(path, params, headers) {
+    return this.requestWithRetry({
+      method: "GET",
+      path,
+      params,
+      headers
+    });
+  }
+  async post(path, body, params, headers) {
+    return this.requestWithRetry({
+      method: "POST",
+      path,
+      body,
+      params,
+      headers
+    });
+  }
+  async put(path, body, headers) {
+    return this.requestWithRetry({
+      method: "PUT",
+      path,
+      body,
+      headers
+    });
+  }
+  async delete(path, params, headers) {
+    return this.requestWithRetry({
+      method: "DELETE",
+      path,
+      params,
+      headers
+    });
+  }
+  async *stream(path, body, headers) {
+    const url = this.buildUrl(path);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.defaultHeaders,
+        ...headers
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const data = await response.json().catch(() => ({}));
+      throw createErrorFromResponse(response.status, data);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new RagAgentError("Response body is not readable");
+    }
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = decoder.decode(value, { stream: true });
+        const lines = text.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          yield line;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async uploadFile(path, file, filename, fieldName = "file", extraFields, headers) {
+    const url = this.buildUrl(path);
+    const formData = new FormData();
+    const blob = file instanceof ArrayBuffer ? new Blob([file]) : file;
+    formData.append(fieldName, blob, filename);
+    if (extraFields) {
+      for (const [key, value] of Object.entries(extraFields)) {
+        formData.append(key, value);
+      }
+    }
+    const uploadHeaders = { ...headers };
+    delete uploadHeaders["Content-Type"];
+    const response = await fetch(url, {
+      method: "POST",
+      headers: uploadHeaders,
+      body: formData
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * Update default headers
+   */
+  setHeaders(headers) {
+    Object.assign(this.defaultHeaders, headers);
+  }
+};
+
+// src/auth.ts
+var AuthHandler = class {
+  constructor(config) {
+    this.config = {
+      apiKeyHeader: "X-API-Key",
+      ...config
+    };
+  }
+  /**
+   * Set HTTP client for login requests
+   */
+  setHttpClient(client) {
+    this.httpClient = client;
+  }
+  /**
+   * Check if any credentials are configured
+   */
+  hasCredentials() {
+    return !!(this.config.apiKey || this.config.jwtToken || this.config.supabaseServiceKey || this.config.supabaseAccessToken || this.config.username && this.config.password);
+  }
+  /**
+   * Get the active authentication method
+   */
+  getAuthMethod() {
+    if (this.config.apiKey) return "api_key";
+    if (this.config.supabaseServiceKey) return "supabase_service";
+    if (this.config.supabaseAnonKey && this.config.supabaseAccessToken) return "supabase_anon_jwt";
+    if (this.config.jwtToken) return "jwt_token";
+    if (this.config.username && this.config.password) return "password";
+    return null;
+  }
+  /**
+   * Get authentication headers for requests
+   */
+  async getHeaders() {
+    const headers = {};
+    const authMethod = this.getAuthMethod();
+    if (authMethod === "api_key") {
+      headers[this.config.apiKeyHeader] = this.config.apiKey;
+      return headers;
+    }
+    if (authMethod === "supabase_service") {
+      headers["apikey"] = this.config.supabaseServiceKey;
+      return headers;
+    }
+    if (authMethod === "supabase_anon_jwt") {
+      headers["apikey"] = this.config.supabaseAnonKey;
+      headers["Authorization"] = `Bearer ${this.config.supabaseAccessToken}`;
+      return headers;
+    }
+    const token = await this.getValidToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  /**
+   * Get a valid access token, refreshing if needed
+   */
+  async getValidToken() {
+    if (this.config.jwtToken) {
+      return this.config.jwtToken;
+    }
+    if (this.config.supabaseAccessToken) {
+      return this.config.supabaseAccessToken;
+    }
+    if (this.tokenInfo?.accessToken) {
+      if (this.isTokenValid()) {
+        return this.tokenInfo.accessToken;
+      }
+      if (this.tokenInfo.refreshToken) {
+        await this.refreshAccessToken();
+        if (this.tokenInfo?.accessToken) {
+          return this.tokenInfo.accessToken;
+        }
+      }
+    }
+    if (this.config.username && this.config.password) {
+      await this.login();
+      return this.tokenInfo?.accessToken ?? null;
+    }
+    return null;
+  }
+  /**
+   * Check if the current token is still valid
+   */
+  isTokenValid() {
+    if (!this.tokenInfo?.accessToken) {
+      return false;
+    }
+    if (!this.tokenInfo.expiresAt) {
+      return true;
+    }
+    const bufferMs = 5 * 60 * 1e3;
+    return (/* @__PURE__ */ new Date()).getTime() < this.tokenInfo.expiresAt.getTime() - bufferMs;
+  }
+  /**
+   * Login with username and password
+   */
+  async login() {
+    if (!this.httpClient) {
+      return;
+    }
+    try {
+      const response = await this.httpClient.post("/login", {
+        username: this.config.username,
+        password: this.config.password
+      });
+      const expiresIn = response.expires_in ?? 3600;
+      this.tokenInfo = {
+        accessToken: response.access_token,
+        expiresAt: new Date(Date.now() + expiresIn * 1e3),
+        refreshToken: response.refresh_token
+      };
+    } catch {
+      this.tokenInfo = void 0;
+      throw new Error("Login failed");
+    }
+  }
+  /**
+   * Refresh the access token using refresh token
+   */
+  async refreshAccessToken() {
+    if (!this.httpClient || !this.tokenInfo?.refreshToken) {
+      return;
+    }
+    try {
+      const response = await this.httpClient.post("/auth/refresh", {
+        refresh_token: this.tokenInfo.refreshToken
+      });
+      const expiresIn = response.expires_in ?? 3600;
+      this.tokenInfo = {
+        accessToken: response.access_token,
+        expiresAt: new Date(Date.now() + expiresIn * 1e3),
+        refreshToken: response.refresh_token ?? this.tokenInfo.refreshToken
+      };
+    } catch {
+      this.tokenInfo = void 0;
+    }
+  }
+  /**
+   * Clear authentication state
+   */
+  logout() {
+    this.tokenInfo = void 0;
+  }
+  /**
+   * Check if currently authenticated
+   */
+  isAuthenticated() {
+    return !!(this.config.apiKey || this.config.jwtToken || this.config.supabaseServiceKey || this.config.supabaseAccessToken || this.tokenInfo?.accessToken);
+  }
+};
+
+// src/datasets.ts
+var DatasetsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new dataset
+   */
+  async create(options) {
+    const response = await this.http.post("/datasets", options);
+    return "dataset" in response ? response.dataset : response;
+  }
+  /**
+   * Get dataset by ID
+   */
+  async get(datasetId) {
+    try {
+      const response = await this.http.get(`/datasets/${datasetId}`);
+      return "dataset" in response ? response.dataset : response;
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("not found")) {
+        throw new DatasetNotFoundError(datasetId);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get dataset by name
+   */
+  async getByName(name) {
+    const result = await this.list({ pageSize: 100 });
+    const dataset = result.datasets.find((d) => d.name === name);
+    return dataset ?? null;
+  }
+  /**
+   * List datasets
+   */
+  async list(options = {}) {
+    const params = {
+      page: options.page ?? 1,
+      page_size: options.pageSize ?? 20,
+      status: options.status,
+      visibility: options.visibility,
+      owner_id: options.ownerId
+    };
+    const response = await this.http.get("/datasets", params);
+    return response;
+  }
+  /**
+   * Update dataset
+   */
+  async update(datasetId, updates) {
+    const response = await this.http.put(
+      `/datasets/${datasetId}`,
+      updates
+    );
+    return "dataset" in response ? response.dataset : response;
+  }
+  /**
+   * Delete dataset
+   */
+  async delete(datasetId) {
+    return this.http.delete(`/datasets/${datasetId}`);
+  }
+  /**
+   * Update model configuration for a dataset
+   */
+  async updateModelConfig(datasetId, modelConfig, _force = false) {
+    const response = await this.http.put(
+      `/datasets/${datasetId}/model-config`,
+      modelConfig
+    );
+    return "dataset" in response ? response.dataset : response;
+  }
+};
+
+// src/documents.ts
+var DocumentsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload a document file to a dataset
+   */
+  async upload(datasetId, file, options = {}) {
+    let filename = options.filename;
+    if (!filename && file instanceof File) {
+      filename = file.name;
+    }
+    if (!filename) {
+      throw new Error("filename is required when file is not a File object");
+    }
+    return this.http.uploadFile(
+      `/datasets/${datasetId}/documents/upload`,
+      file,
+      filename
+    );
+  }
+  /**
+   * Insert text content into a dataset
+   */
+  async insertText(datasetId, text, source) {
+    const body = { text };
+    if (source) {
+      body.file_source = source;
+    }
+    return this.http.post(
+      `/datasets/${datasetId}/documents/text`,
+      body
+    );
+  }
+  /**
+   * Insert multiple texts into a dataset
+   */
+  async insertBatch(datasetId, texts, sources) {
+    const body = { texts };
+    if (sources) {
+      body.file_sources = sources;
+    }
+    return this.http.post(
+      `/datasets/${datasetId}/documents/texts`,
+      body
+    );
+  }
+  /**
+   * List documents in a dataset
+   */
+  async list(datasetId, options = {}) {
+    const params = {
+      page: options.page ?? 1,
+      page_size: options.pageSize ?? 20,
+      status: options.status
+    };
+    return this.http.get(
+      `/datasets/${datasetId}/documents`,
+      params
+    );
+  }
+  /**
+   * Get document by ID
+   */
+  async get(datasetId, docId) {
+    try {
+      return await this.http.get(
+        `/datasets/${datasetId}/documents/${docId}`
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("not found")) {
+        throw new DocumentNotFoundError(docId, datasetId);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get document processing status by tracking ID
+   * @param datasetId - Dataset UUID
+   * @param trackId - Tracking ID returned from upload/insert operations
+   * @returns Object containing track_id, documents list, total_count, and status_summary
+   */
+  async getStatus(datasetId, trackId) {
+    return this.http.get(
+      `/datasets/${datasetId}/track_status/${trackId}`
+    );
+  }
+  /**
+   * Delete a document
+   */
+  async delete(datasetId, docId) {
+    return this.http.delete(
+      `/datasets/${datasetId}/documents/${docId}`
+    );
+  }
+  /**
+   * Delete multiple documents
+   */
+  async deleteBatch(datasetId, docIds) {
+    return this.http.post(
+      `/datasets/${datasetId}/documents/delete-batch`,
+      { doc_ids: docIds }
+    );
+  }
+  /**
+   * Scan and index new documents in the dataset
+   */
+  async scan(datasetId) {
+    return this.http.post(
+      `/datasets/${datasetId}/documents/scan`
+    );
+  }
+  /**
+   * Clear all documents in a dataset
+   */
+  async clear(datasetId) {
+    return this.http.post(
+      `/datasets/${datasetId}/documents/clear`
+    );
+  }
+  /**
+   * Upload a document from a remote URL
+   */
+  async uploadRemote(datasetId, url, filename) {
+    const body = { url };
+    if (filename) {
+      body.filename = filename;
+    }
+    return this.http.post(
+      `/datasets/${datasetId}/documents/upload-remote`,
+      body
+    );
+  }
+};
+
+// src/types.ts
+var DocStatus = /* @__PURE__ */ ((DocStatus2) => {
+  DocStatus2["PENDING"] = "pending";
+  DocStatus2["PROCESSING"] = "processing";
+  DocStatus2["PROCESSED"] = "processed";
+  DocStatus2["FAILED"] = "failed";
+  DocStatus2["MULTIMODAL_PARSING"] = "multimodal_parsing";
+  DocStatus2["MULTIMODAL_PROCESSING"] = "multimodal_processing";
+  return DocStatus2;
+})(DocStatus || {});
+var QueryMode = /* @__PURE__ */ ((QueryMode2) => {
+  QueryMode2["LOCAL"] = "local";
+  QueryMode2["GLOBAL"] = "global";
+  QueryMode2["HYBRID"] = "hybrid";
+  QueryMode2["NAIVE"] = "naive";
+  QueryMode2["MIX"] = "mix";
+  QueryMode2["BYPASS"] = "bypass";
+  return QueryMode2;
+})(QueryMode || {});
+var StorageType = /* @__PURE__ */ ((StorageType2) => {
+  StorageType2["LOCAL"] = "local";
+  StorageType2["SUPABASE"] = "supabase";
+  StorageType2["S3"] = "s3";
+  StorageType2["ALIYUN_OSS"] = "aliyun-oss";
+  return StorageType2;
+})(StorageType || {});
+var ChunkEngine = /* @__PURE__ */ ((ChunkEngine2) => {
+  ChunkEngine2["TOKEN"] = "token";
+  ChunkEngine2["SENTENCE"] = "sentence";
+  ChunkEngine2["SEMANTIC"] = "semantic";
+  ChunkEngine2["RECURSIVE"] = "recursive";
+  return ChunkEngine2;
+})(ChunkEngine || {});
+var Visibility = /* @__PURE__ */ ((Visibility2) => {
+  Visibility2["PRIVATE"] = "private";
+  Visibility2["PUBLIC"] = "public";
+  return Visibility2;
+})(Visibility || {});
+
+// src/query.ts
+function toSnakeCase(options) {
+  const result = {};
+  if (options.mode !== void 0) result.mode = options.mode;
+  if (options.onlyNeedContext !== void 0) result.only_need_context = options.onlyNeedContext;
+  if (options.onlyNeedPrompt !== void 0) result.only_need_prompt = options.onlyNeedPrompt;
+  if (options.responseType !== void 0) result.response_type = options.responseType;
+  if (options.topK !== void 0) result.top_k = options.topK;
+  if (options.chunkTopK !== void 0) result.chunk_top_k = options.chunkTopK;
+  if (options.maxEntityTokens !== void 0) result.max_entity_tokens = options.maxEntityTokens;
+  if (options.maxRelationTokens !== void 0) result.max_relation_tokens = options.maxRelationTokens;
+  if (options.maxTotalTokens !== void 0) result.max_total_tokens = options.maxTotalTokens;
+  if (options.conversationHistory !== void 0) result.conversation_history = options.conversationHistory;
+  if (options.historyTurns !== void 0) result.history_turns = options.historyTurns;
+  if (options.ids !== void 0) result.ids = options.ids;
+  if (options.userPrompt !== void 0) result.user_prompt = options.userPrompt;
+  if (options.enableRerank !== void 0) result.enable_rerank = options.enableRerank;
+  if (options.imageBase64 !== void 0) result.image_base64 = options.imageBase64;
+  if (options.imageUrl !== void 0) result.image_url = options.imageUrl;
+  return result;
+}
+var QueryClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Execute a RAG query on a dataset
+   */
+  async query(datasetId, query, options = {}) {
+    const body = {
+      query,
+      ...toSnakeCase(options),
+      mode: options.mode ?? "mix" /* MIX */
+    };
+    return this.http.post(
+      `/datasets/${datasetId}/query`,
+      body
+    );
+  }
+  /**
+   * Execute a streaming RAG query
+   */
+  async *queryStream(datasetId, query, options = {}) {
+    const body = {
+      query,
+      ...toSnakeCase(options),
+      mode: options.mode ?? "mix" /* MIX */
+    };
+    for await (const line of this.http.stream(
+      `/datasets/${datasetId}/query/stream`,
+      body
+    )) {
+      try {
+        const data = JSON.parse(line);
+        if (typeof data.response === "string") {
+          yield data.response;
+        } else if (typeof data.error === "string") {
+          throw new Error(data.error);
+        }
+      } catch (e) {
+        if (e instanceof SyntaxError) {
+          yield line;
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  /**
+   * Execute a query across multiple datasets
+   */
+  async crossDatasetQuery(query, datasetIds, options = {}) {
+    const body = {
+      query,
+      dataset_ids: datasetIds,
+      ...toSnakeCase(options),
+      mode: options.mode ?? "mix" /* MIX */
+    };
+    if (options.documentFilters) {
+      body.document_filters = options.documentFilters;
+    }
+    if (options.maxResultsPerDataset !== void 0) {
+      body.max_results_per_dataset = options.maxResultsPerDataset;
+    }
+    return this.http.post(
+      "/datasets/cross-query",
+      body
+    );
+  }
+  /**
+   * Execute an image-based RAG query
+   */
+  async imageQuery(datasetId, image, query, options = {}) {
+    const body = {
+      ...toSnakeCase(options),
+      mode: options.mode ?? "mix" /* MIX */
+    };
+    if (query) {
+      body.query = query;
+    }
+    if (typeof image === "string") {
+      if (image.startsWith("http://") || image.startsWith("https://")) {
+        body.image_url = image;
+      } else {
+        body.image_base64 = image;
+      }
+    } else {
+      const bytes = new Uint8Array(image);
+      let binary = "";
+      for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      body.image_base64 = btoa(binary);
+    }
+    return this.http.post(
+      `/datasets/${datasetId}/query`,
+      body
+    );
+  }
+  /**
+   * Get only the retrieved context without generating a response
+   */
+  async getContext(datasetId, query, options = {}) {
+    return this.query(datasetId, query, {
+      ...options,
+      onlyNeedContext: true
+    });
+  }
+};
+
+// src/graph.ts
+var GraphClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get knowledge graph subgraph by label
+   */
+  async getKnowledgeGraph(datasetId, label, options = {}) {
+    const params = {
+      label,
+      max_depth: options.maxDepth ?? 3,
+      max_nodes: options.maxNodes ?? 1e3
+    };
+    return this.http.get(
+      `/datasets/${datasetId}/graphs`,
+      params
+    );
+  }
+  /**
+   * Get all graph labels in a dataset
+   */
+  async getLabels(datasetId) {
+    const response = await this.http.get(
+      `/datasets/${datasetId}/graph/label/list`
+    );
+    return Array.isArray(response) ? response : response.labels;
+  }
+  /**
+   * Check if an entity exists in the knowledge graph
+   */
+  async checkEntityExists(datasetId, entityName) {
+    const response = await this.http.get(
+      `/datasets/${datasetId}/graph/entity/exists`,
+      { name: entityName }
+    );
+    return response.exists;
+  }
+  /**
+   * Get entity by name
+   */
+  async getEntity(datasetId, entityName) {
+    try {
+      return await this.http.get(
+        `/datasets/${datasetId}/graph/entity`,
+        { name: entityName }
+      );
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Edit an entity in the knowledge graph
+   */
+  async editEntity(datasetId, entityName, updatedData, allowRename = false) {
+    return this.http.post(
+      `/datasets/${datasetId}/graph/entity/edit`,
+      {
+        entity_name: entityName,
+        updated_data: updatedData,
+        allow_rename: allowRename
+      }
+    );
+  }
+  /**
+   * Edit a relation in the knowledge graph
+   */
+  async editRelation(datasetId, sourceId, targetId, updatedData) {
+    return this.http.post(
+      `/datasets/${datasetId}/graph/relation/edit`,
+      {
+        source_id: sourceId,
+        target_id: targetId,
+        updated_data: updatedData
+      }
+    );
+  }
+  /**
+   * Search for entities matching a query
+   */
+  async searchEntities(datasetId, query, topK = 10) {
+    const response = await this.http.get(
+      `/datasets/${datasetId}/graph/entity/search`,
+      { query, top_k: topK }
+    );
+    return Array.isArray(response) ? response : response.entities;
+  }
+  /**
+   * Search for relations matching a query
+   */
+  async searchRelations(datasetId, query, topK = 10) {
+    const response = await this.http.get(
+      `/datasets/${datasetId}/graph/relation/search`,
+      { query, top_k: topK }
+    );
+    return Array.isArray(response) ? response : response.relations;
+  }
+  /**
+   * Get neighboring entities of a given entity
+   */
+  async getEntityNeighbors(datasetId, entityName, maxDepth = 1) {
+    return this.getKnowledgeGraph(datasetId, entityName, { maxDepth });
+  }
+};
+
+// src/client.ts
+var AuthenticatedHttpClient = class extends HttpClient {
+  constructor(baseUrl, authHandler, config) {
+    super({
+      baseUrl,
+      timeout: config.timeout ?? 3e4,
+      maxRetries: config.maxRetries ?? 3,
+      retryDelay: config.retryDelay ?? 1e3
+    });
+    this.authHandler = authHandler;
+  }
+  async injectAuthHeaders(headers) {
+    const authHeaders = await this.authHandler.getHeaders();
+    return { ...headers, ...authHeaders };
+  }
+  async get(path, params, headers) {
+    const authHeaders = await this.injectAuthHeaders(headers);
+    return super.get(path, params, authHeaders);
+  }
+  async post(path, body, params, headers) {
+    const authHeaders = await this.injectAuthHeaders(headers);
+    return super.post(path, body, params, authHeaders);
+  }
+  async put(path, body, headers) {
+    const authHeaders = await this.injectAuthHeaders(headers);
+    return super.put(path, body, authHeaders);
+  }
+  async delete(path, params, headers) {
+    const authHeaders = await this.injectAuthHeaders(headers);
+    return super.delete(path, params, authHeaders);
+  }
+  async *stream(path, body, headers) {
+    const authHeaders = await this.injectAuthHeaders(headers);
+    yield* super.stream(path, body, authHeaders);
+  }
+  async uploadFile(path, file, filename, fieldName, extraFields, headers) {
+    const authHeaders = await this.injectAuthHeaders(headers);
+    return super.uploadFile(path, file, filename, fieldName, extraFields, authHeaders);
+  }
+};
+var RagAgentClient = class {
+  /**
+   * Create a new RAG Agent client
+   */
+  constructor(config) {
+    const baseUrl = config.baseUrl.replace(/\/$/, "");
+    const authConfig = {
+      apiKey: config.apiKey,
+      apiKeyHeader: config.apiKeyHeader ?? "X-API-Key",
+      jwtToken: config.jwtToken,
+      supabaseUrl: config.supabaseUrl,
+      supabaseAnonKey: config.supabaseAnonKey,
+      supabaseServiceKey: config.supabaseServiceKey,
+      supabaseAccessToken: config.supabaseAccessToken,
+      username: config.username,
+      password: config.password
+    };
+    this.authHandler = new AuthHandler(authConfig);
+    this.http = new AuthenticatedHttpClient(baseUrl, this.authHandler, config);
+    this.authHandler.setHttpClient(this.http);
+    this.datasets = new DatasetsClient(this.http);
+    this.documents = new DocumentsClient(this.http);
+    this.query = new QueryClient(this.http);
+    this.graph = new GraphClient(this.http);
+  }
+  /**
+   * Get the base URL of the RAG Agent server
+   */
+  get baseUrl() {
+    return this.http["baseUrl"];
+  }
+  /**
+   * Check if the client is authenticated
+   */
+  get isAuthenticated() {
+    return this.authHandler.isAuthenticated();
+  }
+  /**
+   * Check server health
+   */
+  async healthCheck() {
+    return this.http.get("/health");
+  }
+  /**
+   * Get server version and configuration info
+   */
+  async getServerInfo() {
+    try {
+      return await this.http.get("/");
+    } catch {
+      return this.healthCheck();
+    }
+  }
+  /**
+   * Logout and clear authentication state
+   */
+  logout() {
+    this.authHandler.logout();
+  }
+};
+
+// src/mock.ts
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var MockDatasetsClient = class {
+  constructor() {
+    this.datasets = /* @__PURE__ */ new Map();
+  }
+  async create(options) {
+    const datasetId = uuid();
+    const dataset = {
+      dataset_uuid: datasetId,
+      name: options.name,
+      description: options.description,
+      rag_type: options.rag_type ?? "rag",
+      storage_type: options.storage_type ?? "local",
+      chunk_engine: options.chunk_engine ?? "token",
+      status: "active",
+      visibility: options.visibility ?? "private",
+      default_permission: options.default_permission ?? "none",
+      args: options.args ?? {},
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.datasets.set(datasetId, dataset);
+    return dataset;
+  }
+  async get(datasetId) {
+    const dataset = this.datasets.get(datasetId);
+    if (!dataset) {
+      throw new Error(`Dataset not found: ${datasetId}`);
+    }
+    return dataset;
+  }
+  async getByName(name) {
+    for (const dataset of this.datasets.values()) {
+      if (dataset.name === name) return dataset;
+    }
+    return null;
+  }
+  async list(options = {}) {
+    const datasets = Array.from(this.datasets.values());
+    const page = options.page ?? 1;
+    const pageSize = options.pageSize ?? 20;
+    const start = (page - 1) * pageSize;
+    return {
+      datasets: datasets.slice(start, start + pageSize),
+      total: datasets.length,
+      page,
+      page_size: pageSize
+    };
+  }
+  async update(datasetId, updates) {
+    const dataset = await this.get(datasetId);
+    Object.assign(dataset, updates, { updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+    return dataset;
+  }
+  async delete(datasetId) {
+    this.datasets.delete(datasetId);
+    return { status: "deleted", message: `Dataset ${datasetId} deleted` };
+  }
+};
+var MockDocumentsClient = class {
+  constructor() {
+    this.documents = /* @__PURE__ */ new Map();
+  }
+  async upload(datasetId, _file, options) {
+    return this.insertInternal(datasetId, `Uploaded: ${options?.filename ?? "file"}`);
+  }
+  async insertText(datasetId, text, _source) {
+    return this.insertInternal(datasetId, text);
+  }
+  async insertInternal(datasetId, content) {
+    const docId = uuid();
+    const trackId = `track-${uuid().slice(0, 8)}`;
+    if (!this.documents.has(datasetId)) {
+      this.documents.set(datasetId, /* @__PURE__ */ new Map());
+    }
+    this.documents.get(datasetId).set(docId, {
+      id: docId,
+      content_summary: content.slice(0, 100),
+      content_length: content.length,
+      status: "processed" /* PROCESSED */,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      status: "success",
+      message: "Document inserted",
+      track_id: trackId,
+      doc_id: docId
+    };
+  }
+  async insertBatch(datasetId, texts, _sources) {
+    for (const text of texts) {
+      await this.insertInternal(datasetId, text);
+    }
+    return {
+      status: "success",
+      message: `Inserted ${texts.length} documents`,
+      track_id: `batch-${uuid().slice(0, 8)}`
+    };
+  }
+  async list(datasetId, options = {}) {
+    const docs = Array.from(this.documents.get(datasetId)?.values() ?? []);
+    const page = options.page ?? 1;
+    const pageSize = options.pageSize ?? 20;
+    const start = (page - 1) * pageSize;
+    return {
+      documents: docs.slice(start, start + pageSize),
+      total: docs.length,
+      page,
+      page_size: pageSize
+    };
+  }
+  async get(datasetId, docId) {
+    const doc = this.documents.get(datasetId)?.get(docId);
+    if (!doc) throw new Error(`Document not found: ${docId}`);
+    return doc;
+  }
+  async getStatus(datasetId, docId) {
+    return this.get(datasetId, docId);
+  }
+  async delete(datasetId, docId) {
+    this.documents.get(datasetId)?.delete(docId);
+    return { status: "deleted" };
+  }
+  async scan(_datasetId) {
+    return {
+      status: "success",
+      message: "Scan completed",
+      track_id: `scan-${uuid().slice(0, 8)}`
+    };
+  }
+  async clear(datasetId) {
+    this.documents.set(datasetId, /* @__PURE__ */ new Map());
+    return { status: "cleared" };
+  }
+};
+var MockQueryClient = class {
+  constructor(defaultResponse = "This is a mock response from RAG Agent SDK.") {
+    this.responses = /* @__PURE__ */ new Map();
+    this.defaultResponse = defaultResponse;
+  }
+  /**
+   * Set a custom response for a specific query
+   */
+  setResponse(query, response) {
+    this.responses.set(query, response);
+  }
+  async query(datasetId, query, options = {}) {
+    const response = this.responses.get(query) ?? this.defaultResponse;
+    return {
+      response,
+      dataset_id: datasetId,
+      query_mode: options.mode ?? "mix" /* MIX */,
+      entities: [{ name: "MockEntity", type: "test", description: "A mock entity", properties: {} }],
+      chunks: []
+    };
+  }
+  async *queryStream(_datasetId, query, _options = {}) {
+    const response = this.responses.get(query) ?? this.defaultResponse;
+    for (const word of response.split(" ")) {
+      yield word + " ";
+    }
+  }
+  async crossDatasetQuery(query, datasetIds, options = {}) {
+    const response = this.responses.get(query) ?? this.defaultResponse;
+    return {
+      response,
+      query,
+      dataset_count: datasetIds.length,
+      total_chunks: 0,
+      query_mode: options.mode ?? "mix" /* MIX */,
+      dataset_results: {}
+    };
+  }
+  async getContext(_datasetId, _query, options = {}) {
+    return {
+      response: "",
+      dataset_id: _datasetId,
+      query_mode: options.mode ?? "mix" /* MIX */,
+      entities: [
+        { name: "MockEntity1", type: "concept", description: "Mock entity 1", properties: {} },
+        { name: "MockEntity2", type: "concept", description: "Mock entity 2", properties: {} }
+      ],
+      relationships: [
+        { source: "MockEntity1", target: "MockEntity2", type: "related_to", properties: {} }
+      ],
+      chunks: []
+    };
+  }
+};
+var MockGraphClient = class {
+  async getKnowledgeGraph(_datasetId, label, _options) {
+    return {
+      nodes: [
+        { id: "1", label, properties: {} },
+        { id: "2", label: "RelatedNode", properties: {} }
+      ],
+      edges: [{ source: "1", target: "2", type: "connected_to" }]
+    };
+  }
+  async getLabels(_datasetId) {
+    return ["MockLabel1", "MockLabel2", "MockLabel3"];
+  }
+  async checkEntityExists(_datasetId, _entityName) {
+    return true;
+  }
+  async getEntity(_datasetId, entityName) {
+    return {
+      name: entityName,
+      type: "mock",
+      description: `Mock entity: ${entityName}`,
+      properties: {}
+    };
+  }
+  async editEntity(_datasetId, entityName, _updatedData, _allowRename) {
+    return { status: "updated", entity_name: entityName };
+  }
+  async searchEntities(_datasetId, _query, topK = 10) {
+    return Array.from({ length: Math.min(topK, 3) }, (_, i) => ({
+      name: `Result${i}`,
+      type: "mock",
+      description: `Search result ${i}`,
+      properties: {}
+    }));
+  }
+};
+var MockRagAgentClient = class {
+  constructor(defaultResponse = "This is a mock response.") {
+    this.datasets = new MockDatasetsClient();
+    this.documents = new MockDocumentsClient();
+    this.graph = new MockGraphClient();
+    this.query = new MockQueryClient(defaultResponse);
+  }
+  get baseUrl() {
+    return "http://mock-server:9621";
+  }
+  get isAuthenticated() {
+    return true;
+  }
+  async healthCheck() {
+    return { status: "healthy", mock: true };
+  }
+  logout() {
+  }
+};
+
+// src/config.ts
+var ENV_BASE_URL = "RAG_AGENT_BASE_URL";
+var ENV_API_KEY = "RAG_AGENT_API_KEY";
+var ENV_JWT_TOKEN = "RAG_AGENT_JWT_TOKEN";
+var ENV_TIMEOUT = "RAG_AGENT_TIMEOUT";
+var ENV_MAX_RETRIES = "RAG_AGENT_MAX_RETRIES";
+var ENV_DEBUG = "RAG_AGENT_DEBUG";
+var ENV_SUPABASE_URL = "RAG_AGENT_SUPABASE_URL";
+var ENV_SUPABASE_ANON_KEY = "RAG_AGENT_SUPABASE_ANON_KEY";
+var ENV_SUPABASE_SERVICE_KEY = "RAG_AGENT_SUPABASE_SERVICE_KEY";
+var ENV_SUPABASE_ACCESS_TOKEN = "RAG_AGENT_SUPABASE_ACCESS_TOKEN";
+var DEFAULT_BASE_URL = "http://localhost:9621";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+function getEnv(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+function getEnvBool(name, defaultValue = false) {
+  const value = getEnv(name)?.toLowerCase();
+  if (value === "true" || value === "1" || value === "yes") return true;
+  if (value === "false" || value === "0" || value === "no") return false;
+  return defaultValue;
+}
+function getEnvNumber(name, defaultValue) {
+  const value = getEnv(name);
+  if (value) {
+    const num = parseInt(value, 10);
+    if (!isNaN(num)) return num;
+  }
+  return defaultValue;
+}
+var SDKConfig = class _SDKConfig {
+  constructor(options = {}) {
+    this.sdkVersion = "0.1.0";
+    this.baseUrl = options.baseUrl ?? getEnv(ENV_BASE_URL) ?? DEFAULT_BASE_URL;
+    this.apiKey = options.apiKey ?? getEnv(ENV_API_KEY);
+    this.jwtToken = options.jwtToken ?? getEnv(ENV_JWT_TOKEN);
+    this.timeout = options.timeout ?? getEnvNumber(ENV_TIMEOUT, DEFAULT_TIMEOUT);
+    this.maxRetries = options.maxRetries ?? getEnvNumber(ENV_MAX_RETRIES, DEFAULT_MAX_RETRIES);
+    this.retryDelay = options.retryDelay ?? DEFAULT_RETRY_DELAY;
+    this.apiKeyHeader = options.apiKeyHeader ?? "X-API-Key";
+    this.supabaseUrl = options.supabaseUrl ?? getEnv(ENV_SUPABASE_URL);
+    this.supabaseAnonKey = options.supabaseAnonKey ?? getEnv(ENV_SUPABASE_ANON_KEY);
+    this.supabaseServiceKey = options.supabaseServiceKey ?? getEnv(ENV_SUPABASE_SERVICE_KEY);
+    this.supabaseAccessToken = options.supabaseAccessToken ?? getEnv(ENV_SUPABASE_ACCESS_TOKEN);
+    this.username = options.username;
+    this.password = options.password;
+    this.debug = options.debug ?? getEnvBool(ENV_DEBUG, false);
+  }
+  /**
+   * Create configuration from environment variables with optional overrides
+   */
+  static fromEnv(overrides = {}) {
+    return new _SDKConfig(overrides);
+  }
+  /**
+   * Check if any authentication is configured
+   */
+  hasAuth() {
+    return !!(this.apiKey || this.jwtToken || this.supabaseServiceKey || this.supabaseAccessToken || this.username && this.password);
+  }
+  /**
+   * Validate configuration
+   */
+  validate() {
+    if (!this.baseUrl) {
+      throw new Error(
+        `Missing base URL. Set ${ENV_BASE_URL} environment variable or pass baseUrl option.`
+      );
+    }
+    if (!this.hasAuth()) {
+      console.warn(
+        `No authentication configured. Set ${ENV_API_KEY} environment variable or pass apiKey option for authenticated requests.`
+      );
+    }
+  }
+  /**
+   * Get user agent string
+   */
+  getUserAgent() {
+    return `rag-agent-sdk-typescript/${this.sdkVersion}`;
+  }
+};
+function getDefaultConfig() {
+  return SDKConfig.fromEnv();
+}
+
+// src/logger.ts
+var REQUEST_ID_HEADER = "X-Request-ID";
+var SDK_VERSION_HEADER = "X-SDK-Version";
+var SDK_LANGUAGE_HEADER = "X-SDK-Language";
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
+var SDKLogger = class {
+  constructor(config = {}) {
+    this.level = config.level ?? "warn";
+    this.debug = config.debug ?? false;
+    this.sdkVersion = config.sdkVersion ?? "0.1.0";
+    if (this.debug) {
+      this.level = "debug";
+    }
+  }
+  /**
+   * Generate a unique request ID for tracing
+   */
+  generateRequestId() {
+    const random = Math.random().toString(36).substring(2, 10);
+    const timestamp = Date.now().toString(36);
+    return `sdk-${timestamp}${random}`;
+  }
+  /**
+   * Get headers to include in API requests
+   */
+  getRequestHeaders(requestId) {
+    return {
+      [REQUEST_ID_HEADER]: requestId ?? this.generateRequestId(),
+      [SDK_VERSION_HEADER]: this.sdkVersion,
+      [SDK_LANGUAGE_HEADER]: "typescript"
+    };
+  }
+  /**
+   * Check if a log level is enabled
+   */
+  isEnabled(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  /**
+   * Format log message with request ID
+   */
+  formatMessage(requestId, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    return `[${timestamp}] [${requestId}] ${message}`;
+  }
+  /**
+   * Log a debug message
+   */
+  logDebug(requestId, message, data) {
+    if (!this.isEnabled("debug")) return;
+    console.debug(this.formatMessage(requestId, message), data ?? "");
+  }
+  /**
+   * Log an info message
+   */
+  logInfo(requestId, message) {
+    if (!this.isEnabled("info")) return;
+    console.info(this.formatMessage(requestId, message));
+  }
+  /**
+   * Log a warning
+   */
+  logWarn(requestId, message) {
+    if (!this.isEnabled("warn")) return;
+    console.warn(this.formatMessage(requestId, message));
+  }
+  /**
+   * Log an error
+   */
+  logError(requestId, message, error) {
+    if (!this.isEnabled("error")) return;
+    console.error(this.formatMessage(requestId, message), error ?? "");
+  }
+  /**
+   * Log an outgoing request
+   */
+  logRequest(method, url, requestId, body) {
+    this.logDebug(requestId, `-> ${method} ${url}`);
+    if (this.debug && body) {
+      this.logDebug(requestId, `Request body: ${this.truncate(JSON.stringify(body))}`);
+    }
+  }
+  /**
+   * Log an incoming response
+   */
+  logResponse(requestId, statusCode, elapsedMs, body) {
+    const level = statusCode >= 400 ? "warn" : "debug";
+    const message = `<- ${statusCode} (${elapsedMs.toFixed(0)}ms)`;
+    if (level === "warn") {
+      this.logWarn(requestId, message);
+    } else {
+      this.logDebug(requestId, message);
+    }
+    if (this.debug && body) {
+      this.logDebug(requestId, `Response body: ${this.truncate(JSON.stringify(body))}`);
+    }
+  }
+  /**
+   * Log a retry attempt
+   */
+  logRetry(requestId, attempt, maxAttempts, delayMs) {
+    this.logWarn(
+      requestId,
+      `Retry ${attempt}/${maxAttempts} in ${delayMs}ms`
+    );
+  }
+  /**
+   * Truncate long strings for logging
+   */
+  truncate(str, maxLength = 500) {
+    if (str.length > maxLength) {
+      return str.substring(0, maxLength) + "... (truncated)";
+    }
+    return str;
+  }
+};
+function configureLogging(level, debug = false) {
+  return new SDKLogger({ level, debug });
+}
+export {
+  AuthHandler,
+  AuthenticationError,
+  AuthorizationError,
+  ChunkEngine,
+  ConnectionError,
+  DatasetNotFoundError,
+  DatasetsClient,
+  DocStatus,
+  DocumentNotFoundError,
+  DocumentsClient,
+  GraphClient,
+  HttpClient,
+  MockQueryClient,
+  MockRagAgentClient,
+  NotFoundError,
+  QueryClient,
+  QueryMode,
+  RagAgentClient,
+  RagAgentError,
+  RateLimitError,
+  SDKConfig,
+  SDKLogger,
+  ServerError,
+  StorageType,
+  TimeoutError,
+  ValidationError,
+  Visibility,
+  configureLogging,
+  getDefaultConfig
+};