@antfly/sdk 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -31,7 +31,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AntflyClient: () => AntflyClient,
-  default: () => index_default
+  boolean: () => boolean,
+  conjunction: () => conjunction,
+  dateRange: () => dateRange,
+  default: () => index_default,
+  disjunction: () => disjunction,
+  docIds: () => docIds,
+  embedderProviders: () => embedderProviders,
+  fuzzy: () => fuzzy,
+  generatorProviders: () => generatorProviders,
+  geoBoundingBox: () => geoBoundingBox,
+  geoDistance: () => geoDistance,
+  match: () => match,
+  matchAll: () => matchAll,
+  matchNone: () => matchNone,
+  matchPhrase: () => matchPhrase,
+  numericRange: () => numericRange,
+  prefix: () => prefix,
+  queryString: () => queryString,
+  term: () => term
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -46,8 +64,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;
       },
@@ -55,7 +75,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}`);
@@ -65,7 +85,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
         });
@@ -76,28 +96,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
@@ -109,7 +141,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
         });
@@ -120,7 +152,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
         });
@@ -131,11 +163,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);
       }
     };
     /**
@@ -146,7 +188,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}`);
@@ -156,7 +198,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}`);
@@ -165,9 +207,9 @@ var AntflyClient = class {
       /**
        * Create a new index
        */
-      create: async (tableName, indexName, config) => {
-        const { error } = await this.client.POST("/table/{tableName}/index/{indexName}", {
-          params: { path: { tableName, indexName } },
+      create: async (tableName, config) => {
+        const { error } = await this.client.POST("/tables/{tableName}/indexes/{indexName}", {
+          params: { path: { tableName, indexName: config.name } },
           body: config
         });
         if (error) throw new Error(`Failed to create index: ${error.error}`);
@@ -177,7 +219,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}`);
@@ -188,11 +230,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}`);
@@ -202,7 +260,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
         });
@@ -213,7 +271,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}`);
@@ -223,7 +281,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 }
         });
@@ -234,7 +292,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}`);
@@ -244,7 +302,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
         });
@@ -255,7 +313,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 }
@@ -276,7 +334,13 @@ var AntflyClient = class {
     }
     this.client = (0, import_openapi_fetch.default)({
       baseUrl: config.baseUrl,
-      headers
+      headers,
+      bodySerializer: (body) => {
+        if (typeof body === "string") {
+          return body;
+        }
+        return JSON.stringify(body);
+      }
     });
   }
   /**
@@ -290,20 +354,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(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(data);
+                      }
+                      break;
+                    case "confidence":
+                      if (callbacks.onConfidence) {
+                        const confidence = JSON.parse(data);
+                        callbacks.onConfidence(confidence);
+                      }
+                      break;
+                    case "followup_question":
+                      if (callbacks.onFollowUpQuestion) {
+                        callbacks.onFollowUpQuestion(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}`;
     }
-    return data?.responses?.[0];
+    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}`);
+    }
+    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(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
@@ -313,9 +857,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 embedderProviders = [
+  "ollama",
+  "gemini",
+  "openai",
+  "bedrock"
+];
+var generatorProviders = [
+  "ollama",
+  "gemini",
+  "openai",
+  "bedrock",
+  "anthropic"
+];
+
 // src/index.ts
 var index_default = AntflyClient;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AntflyClient
+  AntflyClient,
+  boolean,
+  conjunction,
+  dateRange,
+  disjunction,
+  docIds,
+  embedderProviders,
+  fuzzy,
+  generatorProviders,
+  geoBoundingBox,
+  geoDistance,
+  match,
+  matchAll,
+  matchNone,
+  matchPhrase,
+  numericRange,
+  prefix,
+  queryString,
+  term
 });