@antfly/sdk 0.0.5 → 0.0.7

package/dist/index.js

@@ -9,8 +9,10 @@ var AntflyClient = class {
       /**
        * List all tables
        */
-      list: async () => {
-        const { data, error } = await this.client.GET("/table", {});
+      list: async (params) => {
+        const { data, error } = await this.client.GET("/tables", {
+          params: params ? { query: params } : void 0
+        });
         if (error) throw new Error(`Failed to list tables: ${error.error}`);
         return data;
       },
@@ -18,7 +20,7 @@ var AntflyClient = class {
        * Get table details and status
        */
       get: async (tableName) => {
-        const { data, error } = await this.client.GET("/table/{tableName}", {
+        const { data, error } = await this.client.GET("/tables/{tableName}", {
           params: { path: { tableName } }
         });
         if (error) throw new Error(`Failed to get table: ${error.error}`);
@@ -28,7 +30,7 @@ var AntflyClient = class {
        * Create a new table
        */
       create: async (tableName, config = {}) => {
-        const { data, error } = await this.client.POST("/table/{tableName}", {
+        const { data, error } = await this.client.POST("/tables/{tableName}", {
           params: { path: { tableName } },
           body: config
         });
@@ -39,28 +41,40 @@ var AntflyClient = class {
        * Drop a table
        */
       drop: async (tableName) => {
-        const { error } = await this.client.DELETE("/table/{tableName}", {
+        const { error } = await this.client.DELETE("/tables/{tableName}", {
           params: { path: { tableName } }
         });
         if (error) throw new Error(`Failed to drop table: ${error.error}`);
         return true;
       },
       /**
-       * Query a specific table
+       * Update schema for a table
        */
-      query: async (tableName, request) => {
-        const { data, error } = await this.client.POST("/table/{tableName}/query", {
+      updateSchema: async (tableName, config) => {
+        const { data, error } = await this.client.PUT("/tables/{tableName}/schema", {
           params: { path: { tableName } },
-          body: request
+          body: config
         });
-        if (error) throw new Error(`Table query failed: ${error.error}`);
+        if (error) throw new Error(`Failed to update table schema: ${error.error}`);
         return data;
       },
+      /**
+       * Query a specific table
+       */
+      query: async (tableName, request) => {
+        return this.performQuery("/tables/{tableName}/query", request, tableName);
+      },
+      /**
+       * Execute multiple queries on a specific table
+       */
+      multiquery: async (tableName, requests) => {
+        return this.performMultiquery("/tables/{tableName}/query", requests, tableName);
+      },
       /**
        * Perform batch operations on a table
        */
       batch: async (tableName, request) => {
-        const { data, error } = await this.client.POST("/table/{tableName}/batch", {
+        const { data, error } = await this.client.POST("/tables/{tableName}/batch", {
           params: { path: { tableName } },
           // @ts-expect-error Our BatchRequest type allows any object shape for inserts
           body: request
@@ -72,7 +86,7 @@ var AntflyClient = class {
        * Backup a table
        */
       backup: async (tableName, request) => {
-        const { data, error } = await this.client.POST("/table/{tableName}/backup", {
+        const { data, error } = await this.client.POST("/tables/{tableName}/backup", {
           params: { path: { tableName } },
           body: request
         });
@@ -83,7 +97,7 @@ var AntflyClient = class {
        * Restore a table from backup
        */
       restore: async (tableName, request) => {
-        const { data, error } = await this.client.POST("/table/{tableName}/restore", {
+        const { data, error } = await this.client.POST("/tables/{tableName}/restore", {
           params: { path: { tableName } },
           body: request
         });
@@ -94,11 +108,21 @@ var AntflyClient = class {
        * Lookup a specific key in a table
        */
       lookup: async (tableName, key) => {
-        const { data, error } = await this.client.GET("/table/{tableName}/key/{key}", {
+        const { data, error } = await this.client.GET("/tables/{tableName}/lookup/{key}", {
           params: { path: { tableName, key } }
         });
         if (error) throw new Error(`Key lookup failed: ${error.error}`);
         return data;
+      },
+      /**
+       * RAG (Retrieval-Augmented Generation) query on a specific table with streaming or citations
+       * @param tableName - Name of the table to query
+       * @param request - RAG request with query and summarizer config (set with_streaming: true to enable streaming)
+       * @param callbacks - Optional callbacks for structured SSE events (hit, summary, citation, done, error)
+       * @returns Promise with RAG result (JSON) or AbortController (when streaming)
+       */
+      rag: async (tableName, request, callbacks) => {
+        return this.performRag(`/tables/${tableName}/rag`, request, callbacks);
       }
     };
     /**
@@ -109,7 +133,7 @@ var AntflyClient = class {
        * List all indexes for a table
        */
       list: async (tableName) => {
-        const { data, error } = await this.client.GET("/table/{tableName}/index", {
+        const { data, error } = await this.client.GET("/tables/{tableName}/indexes", {
           params: { path: { tableName } }
         });
         if (error) throw new Error(`Failed to list indexes: ${error.error}`);
@@ -119,7 +143,7 @@ var AntflyClient = class {
        * Get index details
        */
       get: async (tableName, indexName) => {
-        const { data, error } = await this.client.GET("/table/{tableName}/index/{indexName}", {
+        const { data, error } = await this.client.GET("/tables/{tableName}/indexes/{indexName}", {
           params: { path: { tableName, indexName } }
         });
         if (error) throw new Error(`Failed to get index: ${error.error}`);
@@ -129,7 +153,7 @@ var AntflyClient = class {
        * Create a new index
        */
       create: async (tableName, config) => {
-        const { error } = await this.client.POST("/table/{tableName}/index/{indexName}", {
+        const { error } = await this.client.POST("/tables/{tableName}/indexes/{indexName}", {
           params: { path: { tableName, indexName: config.name } },
           body: config
         });
@@ -140,7 +164,7 @@ var AntflyClient = class {
        * Drop an index
        */
       drop: async (tableName, indexName) => {
-        const { error } = await this.client.DELETE("/table/{tableName}/index/{indexName}", {
+        const { error } = await this.client.DELETE("/tables/{tableName}/indexes/{indexName}", {
           params: { path: { tableName, indexName } }
         });
         if (error) throw new Error(`Failed to drop index: ${error.error}`);
@@ -151,11 +175,27 @@ var AntflyClient = class {
      * User management operations
      */
     this.users = {
+      /**
+       * Get current authenticated user
+       */
+      getCurrentUser: async () => {
+        const { data, error } = await this.client.GET("/users/me");
+        if (error) throw new Error(`Failed to get current user: ${error.error}`);
+        return data;
+      },
+      /**
+       * List all users
+       */
+      list: async () => {
+        const { data, error } = await this.client.GET("/users");
+        if (error) throw new Error(`Failed to list users: ${error.error}`);
+        return data;
+      },
       /**
        * Get user details
        */
       get: async (userName) => {
-        const { data, error } = await this.client.GET("/user/{userName}", {
+        const { data, error } = await this.client.GET("/users/{userName}", {
           params: { path: { userName } }
         });
         if (error) throw new Error(`Failed to get user: ${error.error}`);
@@ -165,7 +205,7 @@ var AntflyClient = class {
        * Create a new user
        */
       create: async (userName, request) => {
-        const { data, error } = await this.client.POST("/user/{userName}", {
+        const { data, error } = await this.client.POST("/users/{userName}", {
           params: { path: { userName } },
           body: request
         });
@@ -176,7 +216,7 @@ var AntflyClient = class {
        * Delete a user
        */
       delete: async (userName) => {
-        const { error } = await this.client.DELETE("/user/{userName}", {
+        const { error } = await this.client.DELETE("/users/{userName}", {
           params: { path: { userName } }
         });
         if (error) throw new Error(`Failed to delete user: ${error.error}`);
@@ -186,7 +226,7 @@ var AntflyClient = class {
        * Update user password
        */
       updatePassword: async (userName, newPassword) => {
-        const { data, error } = await this.client.PUT("/user/{userName}/password", {
+        const { data, error } = await this.client.PUT("/users/{userName}/password", {
           params: { path: { userName } },
           body: { new_password: newPassword }
         });
@@ -197,7 +237,7 @@ var AntflyClient = class {
        * Get user permissions
        */
       getPermissions: async (userName) => {
-        const { data, error } = await this.client.GET("/user/{userName}/permission", {
+        const { data, error } = await this.client.GET("/users/{userName}/permissions", {
           params: { path: { userName } }
         });
         if (error) throw new Error(`Failed to get permissions: ${error.error}`);
@@ -207,7 +247,7 @@ var AntflyClient = class {
        * Add permission to user
        */
       addPermission: async (userName, permission) => {
-        const { data, error } = await this.client.POST("/user/{userName}/permission", {
+        const { data, error } = await this.client.POST("/users/{userName}/permissions", {
           params: { path: { userName } },
           body: permission
         });
@@ -218,7 +258,7 @@ var AntflyClient = class {
        * Remove permission from user
        */
       removePermission: async (userName, resource, resourceType) => {
-        const { error } = await this.client.DELETE("/user/{userName}/permission", {
+        const { error } = await this.client.DELETE("/users/{userName}/permissions", {
           params: {
             path: { userName },
             query: { resource, resourceType }
@@ -239,7 +279,13 @@ var AntflyClient = class {
     }
     this.client = createClient({
       baseUrl: config.baseUrl,
-      headers
+      headers,
+      bodySerializer: (body) => {
+        if (typeof body === "string") {
+          return body;
+        }
+        return JSON.stringify(body);
+      }
     });
   }
   /**
@@ -253,20 +299,500 @@ var AntflyClient = class {
       headers: {
         ...this.config.headers,
         Authorization: `Basic ${auth}`
+      },
+      bodySerializer: (body) => {
+        if (typeof body === "string") {
+          return body;
+        }
+        return JSON.stringify(body);
       }
     });
   }
+  /**
+   * Get cluster status
+   */
+  async getStatus() {
+    const { data, error } = await this.client.GET("/status");
+    if (error) throw new Error(`Failed to get status: ${error.error}`);
+    return data;
+  }
+  /**
+   * Private helper for query requests to avoid code duplication
+   */
+  async performQuery(path, request, tableName) {
+    if (path === "/tables/{tableName}/query" && tableName) {
+      const { data, error } = await this.client.POST("/tables/{tableName}/query", {
+        params: { path: { tableName } },
+        body: request
+      });
+      if (error) throw new Error(`Table query failed: ${error.error}`);
+      return data;
+    } else {
+      const { data, error } = await this.client.POST("/query", {
+        body: request
+      });
+      if (error) throw new Error(`Query failed: ${error.error}`);
+      return data;
+    }
+  }
+  /**
+   * Private helper for multiquery requests to avoid code duplication
+   */
+  async performMultiquery(path, requests, tableName) {
+    const ndjson = requests.map((request) => JSON.stringify(request)).join("\n") + "\n";
+    if (path === "/tables/{tableName}/query" && tableName) {
+      const { data, error } = await this.client.POST("/tables/{tableName}/query", {
+        params: { path: { tableName } },
+        body: ndjson,
+        headers: {
+          "Content-Type": "application/x-ndjson"
+        }
+      });
+      if (error) throw new Error(`Table multi-query failed: ${error.error}`);
+      return data;
+    } else {
+      const { data, error } = await this.client.POST("/query", {
+        body: ndjson,
+        headers: {
+          "Content-Type": "application/x-ndjson"
+        }
+      });
+      if (error) throw new Error(`Multi-query failed: ${error.error}`);
+      return data;
+    }
+  }
   /**
    * Global query operations
    */
   async query(request) {
-    const { data, error } = await this.client.POST("/query", {
+    const data = await this.performQuery("/query", request);
+    return data?.responses?.[0];
+  }
+  /**
+   * Execute multiple queries in a single request
+   */
+  async multiquery(requests) {
+    return this.performMultiquery("/query", requests);
+  }
+  /**
+   * Private helper for RAG requests to avoid code duplication
+   */
+  async performRag(path, request, callbacks) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream, application/json"
+    };
+    if (this.config.auth) {
+      const auth = btoa(`${this.config.auth.username}:${this.config.auth.password}`);
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    Object.assign(headers, this.config.headers);
+    const abortController = new AbortController();
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`RAG request failed: ${response.status} ${errorText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const isJSON = contentType.includes("application/json");
+    if (isJSON) {
+      const ragResult = await response.json();
+      return ragResult;
+    }
+    if (callbacks) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentEvent = "";
+      (async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) {
+                currentEvent = "";
+                continue;
+              }
+              if (line.startsWith("event: ")) {
+                currentEvent = line.slice(7).trim();
+              } else if (line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                try {
+                  switch (currentEvent) {
+                    case "hits_start":
+                      if (callbacks.onHitsStart) {
+                        const hitsStartData = JSON.parse(data);
+                        callbacks.onHitsStart(hitsStartData);
+                      }
+                      break;
+                    case "hit":
+                      if (callbacks.onHit) {
+                        const hit = JSON.parse(data);
+                        callbacks.onHit(hit);
+                      }
+                      break;
+                    case "hits_end":
+                      if (callbacks.onHitsEnd) {
+                        const hitsEndData = JSON.parse(data);
+                        callbacks.onHitsEnd(hitsEndData);
+                      }
+                      break;
+                    case "table_result":
+                      if (callbacks.onHit) {
+                        const result = JSON.parse(data);
+                        const hits = result?.hits?.hits || [];
+                        hits.forEach((hit) => callbacks.onHit(hit));
+                      }
+                      break;
+                    case "summary":
+                      if (callbacks.onSummary) {
+                        const chunk = JSON.parse(data);
+                        callbacks.onSummary(chunk);
+                      }
+                      break;
+                    case "done":
+                      if (callbacks.onDone) {
+                        const doneData = JSON.parse(data);
+                        callbacks.onDone(doneData);
+                      }
+                      return;
+                    case "error":
+                      if (callbacks.onError) {
+                        const error = JSON.parse(data);
+                        callbacks.onError(error);
+                      }
+                      throw new Error(data);
+                  }
+                } catch (e) {
+                  console.warn("Failed to parse SSE data:", currentEvent, data, e);
+                }
+              }
+            }
+          }
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            console.error("RAG streaming error:", error);
+          }
+        }
+      })();
+    }
+    return abortController;
+  }
+  /**
+   * Private helper for Answer Agent requests to avoid code duplication
+   */
+  async performAnswerAgent(path, request, callbacks) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream, application/json"
+    };
+    if (this.config.auth) {
+      const auth = btoa(`${this.config.auth.username}:${this.config.auth.password}`);
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    Object.assign(headers, this.config.headers);
+    const abortController = new AbortController();
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Answer agent request failed: ${response.status} ${errorText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const isJSON = contentType.includes("application/json");
+    if (isJSON) {
+      const result = await response.json();
+      return result;
+    }
+    if (callbacks) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentEvent = "";
+      (async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) {
+                currentEvent = "";
+                continue;
+              }
+              if (line.startsWith("event: ")) {
+                currentEvent = line.slice(7).trim();
+              } else if (line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                try {
+                  switch (currentEvent) {
+                    case "classification":
+                      if (callbacks.onClassification) {
+                        const classData = JSON.parse(data);
+                        callbacks.onClassification(classData);
+                      }
+                      break;
+                    case "reasoning":
+                      if (callbacks.onReasoning) {
+                        callbacks.onReasoning(JSON.parse(data));
+                      }
+                      break;
+                    case "hits_start":
+                      if (callbacks.onHitsStart) {
+                        const hitsStartData = JSON.parse(data);
+                        callbacks.onHitsStart(hitsStartData);
+                      }
+                      break;
+                    case "hit":
+                      if (callbacks.onHit) {
+                        const hit = JSON.parse(data);
+                        callbacks.onHit(hit);
+                      }
+                      break;
+                    case "hits_end":
+                      if (callbacks.onHitsEnd) {
+                        const hitsEndData = JSON.parse(data);
+                        callbacks.onHitsEnd(hitsEndData);
+                      }
+                      break;
+                    case "answer":
+                      if (callbacks.onAnswer) {
+                        callbacks.onAnswer(JSON.parse(data));
+                      }
+                      break;
+                    case "confidence":
+                      if (callbacks.onConfidence) {
+                        const confidence = JSON.parse(data);
+                        callbacks.onConfidence(confidence);
+                      }
+                      break;
+                    case "followup_question":
+                      if (callbacks.onFollowUpQuestion) {
+                        callbacks.onFollowUpQuestion(JSON.parse(data));
+                      }
+                      break;
+                    case "done":
+                      if (callbacks.onDone) {
+                        const doneData = JSON.parse(data);
+                        callbacks.onDone(doneData);
+                      }
+                      return;
+                    case "error":
+                      if (callbacks.onError) {
+                        const error = JSON.parse(data);
+                        callbacks.onError(error);
+                      }
+                      throw new Error(data);
+                  }
+                } catch (e) {
+                  console.warn("Failed to parse SSE data:", currentEvent, data, e);
+                }
+              }
+            }
+          }
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            console.error("Answer agent streaming error:", error);
+          }
+        }
+      })();
+    }
+    return abortController;
+  }
+  /**
+   * RAG (Retrieval-Augmented Generation) query with streaming or citations
+   * @param request - RAG request with query and summarizer config (set with_streaming: true to enable streaming)
+   * @param callbacks - Optional callbacks for structured SSE events (hit, summary, citation, done, error)
+   * @returns Promise with RAG result (JSON) or AbortController (when streaming)
+   */
+  async rag(request, callbacks) {
+    return this.performRag("/rag", request, callbacks);
+  }
+  /**
+   * Answer Agent - Intelligent query routing and generation
+   * Automatically classifies queries, generates optimal searches, and provides answers
+   * @param request - Answer agent request with query and generator config
+   * @param callbacks - Optional callbacks for SSE events (classification, hits_start, hit, hits_end, reasoning, answer, followup_question, done, error)
+   * @returns Promise with AnswerAgentResult (JSON) or AbortController (when streaming)
+   */
+  async answerAgent(request, callbacks) {
+    return this.performAnswerAgent("/agents/answer", request, callbacks);
+  }
+  /**
+   * Query Builder Agent - Translates natural language into structured search queries
+   * Uses an LLM to generate optimized Bleve queries from user intent
+   * @param request - Query builder request with intent and optional table/schema context
+   * @returns Promise with QueryBuilderResult containing the generated query, explanation, and confidence
+   */
+  async queryBuilderAgent(request) {
+    const { data, error } = await this.client.POST("/agents/query-builder", {
       body: request
     });
-    if (error) {
-      throw new Error(`Query failed: ${error.error}`);
+    if (error) throw new Error(`Query builder agent failed: ${error.error}`);
+    return data;
+  }
+  /**
+   * Private helper for Chat Agent requests to handle streaming and non-streaming responses
+   */
+  async performChatAgent(path, request, callbacks) {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream, application/json"
+    };
+    if (this.config.auth) {
+      const auth = btoa(`${this.config.auth.username}:${this.config.auth.password}`);
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    Object.assign(headers, this.config.headers);
+    const abortController = new AbortController();
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal: abortController.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Chat agent request failed: ${response.status} ${errorText}`);
     }
-    return data?.responses?.[0];
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const isJSON = contentType.includes("application/json");
+    if (isJSON) {
+      const result = await response.json();
+      return result;
+    }
+    if (callbacks) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentEvent = "";
+      (async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) {
+                currentEvent = "";
+                continue;
+              }
+              if (line.startsWith("event: ")) {
+                currentEvent = line.slice(7).trim();
+              } else if (line.startsWith("data: ")) {
+                const data = line.slice(6).trim();
+                try {
+                  switch (currentEvent) {
+                    case "classification":
+                      if (callbacks.onClassification) {
+                        const classData = JSON.parse(data);
+                        callbacks.onClassification(classData);
+                      }
+                      break;
+                    case "clarification_required":
+                      if (callbacks.onClarificationRequired) {
+                        const clarification = JSON.parse(data);
+                        callbacks.onClarificationRequired(clarification);
+                      }
+                      break;
+                    case "filter_applied":
+                      if (callbacks.onFilterApplied) {
+                        const filter = JSON.parse(data);
+                        callbacks.onFilterApplied(filter);
+                      }
+                      break;
+                    case "search_executed":
+                      if (callbacks.onSearchExecuted) {
+                        const searchData = JSON.parse(data);
+                        callbacks.onSearchExecuted(searchData);
+                      }
+                      break;
+                    case "websearch_executed":
+                      if (callbacks.onWebSearchExecuted) {
+                        const webSearchData = JSON.parse(data);
+                        callbacks.onWebSearchExecuted(webSearchData);
+                      }
+                      break;
+                    case "fetch_executed":
+                      if (callbacks.onFetchExecuted) {
+                        const fetchData = JSON.parse(data);
+                        callbacks.onFetchExecuted(fetchData);
+                      }
+                      break;
+                    case "hit":
+                      if (callbacks.onHit) {
+                        const hit = JSON.parse(data);
+                        callbacks.onHit(hit);
+                      }
+                      break;
+                    case "answer":
+                      if (callbacks.onAnswer) {
+                        callbacks.onAnswer(JSON.parse(data));
+                      }
+                      break;
+                    case "done":
+                      if (callbacks.onDone) {
+                        const doneData = JSON.parse(data);
+                        callbacks.onDone(doneData);
+                      }
+                      return;
+                    case "error":
+                      if (callbacks.onError) {
+                        const error = JSON.parse(data);
+                        callbacks.onError(error);
+                      }
+                      throw new Error(data);
+                  }
+                } catch (e) {
+                  console.warn("Failed to parse SSE data:", currentEvent, data, e);
+                }
+              }
+            }
+          }
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            console.error("Chat agent streaming error:", error);
+          }
+        }
+      })();
+    }
+    return abortController;
+  }
+  /**
+   * Chat Agent - Conversational RAG with multi-turn history and tool calling
+   * Supports filter refinement, clarification requests, and streaming responses
+   * @param request - Chat agent request with conversation history and generator config
+   * @param callbacks - Optional callbacks for SSE events (classification, clarification_required, filter_applied, hit, answer, done, error)
+   * @returns Promise with ChatAgentResult (JSON) or AbortController (when streaming)
+   */
+  async chatAgent(request, callbacks) {
+    return this.performChatAgent("/agents/chat", request, callbacks);
   }
   /**
    * Get the underlying OpenAPI client for advanced use cases
@@ -276,18 +802,184 @@ var AntflyClient = class {
   }
 };
 
+// src/query-helpers.ts
+function queryString(query, boost) {
+  return {
+    query,
+    boost: boost ?? void 0
+  };
+}
+function term(term2, field, boost) {
+  return {
+    term: term2,
+    field,
+    boost: boost ?? void 0
+  };
+}
+function match(match2, field, options) {
+  return {
+    match: match2,
+    field,
+    analyzer: options?.analyzer,
+    boost: options?.boost,
+    prefix_length: options?.prefix_length,
+    fuzziness: options?.fuzziness,
+    operator: options?.operator
+  };
+}
+function matchPhrase(matchPhrase2, field, options) {
+  return {
+    match_phrase: matchPhrase2,
+    field,
+    analyzer: options?.analyzer,
+    boost: options?.boost,
+    fuzziness: options?.fuzziness
+  };
+}
+function prefix(prefix2, field, boost) {
+  return {
+    prefix: prefix2,
+    field,
+    boost: boost ?? void 0
+  };
+}
+function fuzzy(term2, field, options) {
+  return {
+    term: term2,
+    field,
+    fuzziness: options?.fuzziness,
+    prefix_length: options?.prefix_length,
+    boost: options?.boost
+  };
+}
+function numericRange(field, options) {
+  return {
+    field,
+    min: options.min,
+    max: options.max,
+    inclusive_min: options.inclusive_min,
+    inclusive_max: options.inclusive_max,
+    boost: options.boost
+  };
+}
+function dateRange(field, options) {
+  return {
+    field,
+    start: options.start,
+    end: options.end,
+    inclusive_start: options.inclusive_start,
+    inclusive_end: options.inclusive_end,
+    datetime_parser: options.datetime_parser,
+    boost: options.boost
+  };
+}
+function matchAll(boost) {
+  return {
+    match_all: {},
+    boost: boost ?? void 0
+  };
+}
+function matchNone(boost) {
+  return {
+    match_none: {},
+    boost: boost ?? void 0
+  };
+}
+function boolean(options) {
+  const result = {
+    boost: options.boost
+  };
+  if (options.must && options.must.length > 0) {
+    result.must = {
+      conjuncts: options.must
+    };
+  }
+  if (options.should && options.should.length > 0) {
+    result.should = {
+      disjuncts: options.should,
+      min: options.minShouldMatch
+    };
+  }
+  if (options.mustNot && options.mustNot.length > 0) {
+    result.must_not = {
+      disjuncts: options.mustNot
+    };
+  }
+  if (options.filter) {
+    result.filter = options.filter;
+  }
+  return result;
+}
+function conjunction(queries) {
+  return {
+    conjuncts: queries
+  };
+}
+function disjunction(queries, min) {
+  return {
+    disjuncts: queries,
+    min
+  };
+}
+function docIds(ids, boost) {
+  return {
+    ids,
+    boost: boost ?? void 0
+  };
+}
+function geoDistance(field, location, distance, boost) {
+  return {
+    field,
+    location,
+    distance,
+    boost: boost ?? void 0
+  };
+}
+function geoBoundingBox(field, bounds, boost) {
+  return {
+    field,
+    top_left: bounds.top_left,
+    bottom_right: bounds.bottom_right,
+    boost: boost ?? void 0
+  };
+}
+
 // src/types.ts
-var providers = [
+var embedderProviders = [
   "ollama",
   "gemini",
   "openai",
   "bedrock"
 ];
+var generatorProviders = [
+  "ollama",
+  "gemini",
+  "openai",
+  "bedrock",
+  "anthropic"
+];
 
 // src/index.ts
 var index_default = AntflyClient;
 export {
   AntflyClient,
+  boolean,
+  conjunction,
+  dateRange,
   index_default as default,
-  providers
+  disjunction,
+  docIds,
+  embedderProviders,
+  fuzzy,
+  generatorProviders,
+  geoBoundingBox,
+  geoDistance,
+  match,
+  matchAll,
+  matchNone,
+  matchPhrase,
+  numericRange,
+  prefix,
+  queryString,
+  term
 };