@antfly/sdk 0.0.11 → 0.0.13

package/README.md

@@ -183,8 +183,9 @@ const results = await client.query({
     query: 'important document'
   },
   limit: 50,
-  facets: {
+  aggregations: {
     category: {
+      type: 'terms',
       field: 'category',
       size: 10
     }

package/dist/index.cjs

@@ -185,14 +185,14 @@ var AntflyClient = class {
        */
       scan: (tableName, request) => {
         const config = this.config;
+        const authHeader = this.getAuthHeader();
         async function* scanGenerator() {
           const headers = {
             "Content-Type": "application/json",
             Accept: "application/x-ndjson"
           };
-          if (config.auth) {
-            const auth = btoa(`${config.auth.username}:${config.auth.password}`);
-            headers["Authorization"] = `Basic ${auth}`;
+          if (authHeader) {
+            headers["Authorization"] = authHeader;
           }
           Object.assign(headers, config.headers);
           const response = await fetch(`${config.baseUrl}/tables/${tableName}/lookup`, {
@@ -241,16 +241,6 @@ var AntflyClient = class {
           results.push(doc);
         }
         return results;
-      },
-      /**
-       * 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);
       }
     };
     /**
@@ -397,16 +387,41 @@ var AntflyClient = class {
       }
     };
     this.config = config;
+    this.client = this.buildClient();
+  }
+  /**
+   * Build the Authorization header value from the auth config.
+   * Returns undefined if no auth is configured.
+   */
+  getAuthHeader() {
+    const auth = this.config.auth;
+    if (!auth) return void 0;
+    if ("type" in auth) {
+      switch (auth.type) {
+        case "basic":
+          return `Basic ${btoa(`${auth.username}:${auth.password}`)}`;
+        case "apiKey":
+          return `ApiKey ${btoa(`${auth.keyId}:${auth.keySecret}`)}`;
+        case "bearer":
+          return `Bearer ${auth.token}`;
+      }
+    }
+    return `Basic ${btoa(`${auth.username}:${auth.password}`)}`;
+  }
+  /**
+   * Build the openapi-fetch client with current config.
+   */
+  buildClient() {
     const headers = {
       "Content-Type": "application/json",
-      ...config.headers
+      ...this.config.headers
     };
-    if (config.auth) {
-      const auth = btoa(`${config.auth.username}:${config.auth.password}`);
-      headers["Authorization"] = `Basic ${auth}`;
+    const authHeader = this.getAuthHeader();
+    if (authHeader) {
+      headers["Authorization"] = authHeader;
     }
-    this.client = (0, import_openapi_fetch.default)({
-      baseUrl: config.baseUrl,
+    return (0, import_openapi_fetch.default)({
+      baseUrl: this.config.baseUrl,
       headers,
       bodySerializer: (body) => {
         if (typeof body === "string") {
@@ -416,25 +431,13 @@ var AntflyClient = class {
       }
     });
   }
-  /**
-   * Update authentication credentials
-   */
-  setAuth(username, password) {
-    this.config.auth = { username, password };
-    const auth = btoa(`${username}:${password}`);
-    this.client = (0, import_openapi_fetch.default)({
-      baseUrl: this.config.baseUrl,
-      headers: {
-        ...this.config.headers,
-        Authorization: `Basic ${auth}`
-      },
-      bodySerializer: (body) => {
-        if (typeof body === "string") {
-          return body;
-        }
-        return JSON.stringify(body);
-      }
-    });
+  setAuth(authOrUsername, password) {
+    if (typeof authOrUsername === "string" && password !== void 0) {
+      this.config.auth = { username: authOrUsername, password };
+    } else {
+      this.config.auth = authOrUsername;
+    }
+    this.client = this.buildClient();
   }
   /**
    * Get cluster status
@@ -503,136 +506,20 @@ var AntflyClient = class {
     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
+   * Private helper for Retrieval Agent requests to handle streaming and non-streaming responses
    */
-  async performAnswerAgent(path, request, callbacks) {
+  async performRetrievalAgent(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}`;
+    const authHeader = this.getAuthHeader();
+    if (authHeader) {
+      headers["Authorization"] = authHeader;
     }
     Object.assign(headers, this.config.headers);
     const abortController = new AbortController();
-    const response = await fetch(`${this.config.baseUrl}${path}`, {
+    const response = await fetch(`${this.config.baseUrl}/agents/retrieval`, {
       method: "POST",
       headers,
       body: JSON.stringify(request),
@@ -640,7 +527,7 @@ var AntflyClient = class {
     });
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`Answer agent request failed: ${response.status} ${errorText}`);
+      throw new Error(`Retrieval agent request failed: ${response.status} ${errorText}`);
     }
     if (!response.body) {
       throw new Error("Response body is null");
@@ -677,8 +564,7 @@ var AntflyClient = class {
                   switch (currentEvent) {
                     case "classification":
                       if (callbacks.onClassification) {
-                        const classData = JSON.parse(data);
-                        callbacks.onClassification(classData);
+                        callbacks.onClassification(JSON.parse(data));
                       }
                       break;
                     case "reasoning":
@@ -686,56 +572,64 @@ var AntflyClient = class {
                         callbacks.onReasoning(JSON.parse(data));
                       }
                       break;
-                    case "hits_start":
-                      if (callbacks.onHitsStart) {
-                        const hitsStartData = JSON.parse(data);
-                        callbacks.onHitsStart(hitsStartData);
+                    case "clarification_required":
+                      if (callbacks.onClarificationRequired) {
+                        callbacks.onClarificationRequired(JSON.parse(data));
+                      }
+                      break;
+                    case "filter_applied":
+                      if (callbacks.onFilterApplied) {
+                        callbacks.onFilterApplied(JSON.parse(data));
+                      }
+                      break;
+                    case "search_executed":
+                      if (callbacks.onSearchExecuted) {
+                        callbacks.onSearchExecuted(JSON.parse(data));
                       }
                       break;
                     case "hit":
                       if (callbacks.onHit) {
-                        const hit = JSON.parse(data);
-                        callbacks.onHit(hit);
+                        callbacks.onHit(JSON.parse(data));
+                      }
+                      break;
+                    case "generation":
+                      if (callbacks.onGeneration) {
+                        callbacks.onGeneration(JSON.parse(data));
                       }
                       break;
-                    case "hits_end":
-                      if (callbacks.onHitsEnd) {
-                        const hitsEndData = JSON.parse(data);
-                        callbacks.onHitsEnd(hitsEndData);
+                    case "step_started":
+                      if (callbacks.onStepStarted) {
+                        callbacks.onStepStarted(JSON.parse(data));
                       }
                       break;
-                    case "answer":
-                      if (callbacks.onAnswer) {
-                        callbacks.onAnswer(JSON.parse(data));
+                    case "step_completed":
+                      if (callbacks.onStepCompleted) {
+                        callbacks.onStepCompleted(JSON.parse(data));
                       }
                       break;
                     case "confidence":
                       if (callbacks.onConfidence) {
-                        const confidence = JSON.parse(data);
-                        callbacks.onConfidence(confidence);
+                        callbacks.onConfidence(JSON.parse(data));
                       }
                       break;
-                    case "followup_question":
-                      if (callbacks.onFollowUpQuestion) {
-                        callbacks.onFollowUpQuestion(JSON.parse(data));
+                    case "followup":
+                      if (callbacks.onFollowup) {
+                        callbacks.onFollowup(JSON.parse(data));
                       }
                       break;
                     case "eval":
                       if (callbacks.onEvalResult) {
-                        const evalResult = JSON.parse(data);
-                        callbacks.onEvalResult(evalResult);
+                        callbacks.onEvalResult(JSON.parse(data));
                       }
                       break;
                     case "done":
                       if (callbacks.onDone) {
-                        const doneData = JSON.parse(data);
-                        callbacks.onDone(doneData);
+                        callbacks.onDone(JSON.parse(data));
                       }
                       return;
                     case "error":
                       if (callbacks.onError) {
-                        const error = JSON.parse(data);
-                        callbacks.onError(error);
+                        callbacks.onError(JSON.parse(data));
                       }
                       throw new Error(data);
                   }
@@ -747,7 +641,7 @@ var AntflyClient = class {
           }
         } catch (error) {
           if (error.name !== "AbortError") {
-            console.error("Answer agent streaming error:", error);
+            console.error("Retrieval agent streaming error:", error);
           }
         }
       })();
@@ -755,23 +649,83 @@ var AntflyClient = class {
     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)
+   * Retrieval Agent - Unified retrieval pipeline with optional classification, generation, and eval
+   * Supports pipeline mode (structured queries) and agentic mode (tool-calling with LLM)
+   * Configure steps.classification, steps.answer, steps.eval to enable additional pipeline stages
+   * @param request - Retrieval agent request with query, mode, and optional step configs
+   * @param callbacks - Optional callbacks for SSE events (classification, reasoning, hit, answer, citation, confidence, followup_question, eval, done, error)
+   * @returns Promise with RetrievalAgentResult (JSON) or AbortController (when streaming)
    */
-  async rag(request, callbacks) {
-    return this.performRag("/rag", request, callbacks);
+  async retrievalAgent(request, callbacks) {
+    return this.performRetrievalAgent(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)
+   * Chat Agent - Multi-turn conversational retrieval with message history management.
+   * Wraps the retrieval agent with automatic message accumulation.
+   * @param userMessage - The user's message for this turn
+   * @param config - Chat configuration (generator, table, indexes, etc.)
+   * @param history - Previous conversation messages (pass result.messages from prior turns)
+   * @param callbacks - Optional streaming callbacks including chat-specific events
+   * @returns For streaming: { abortController, messages } where messages is a Promise.
+   *          For non-streaming: { result, messages }
    */
-  async answerAgent(request, callbacks) {
-    return this.performAnswerAgent("/agents/answer", request, callbacks);
+  async chatAgent(userMessage, config, history = [], callbacks) {
+    const request = {
+      query: userMessage,
+      queries: [
+        {
+          table: config.table,
+          semantic_search: userMessage,
+          indexes: config.semanticIndexes,
+          limit: config.limit ?? 10
+        }
+      ],
+      generator: config.generator,
+      messages: [...history, { role: "user", content: userMessage }],
+      max_iterations: config.maxIterations ?? 5,
+      stream: !!callbacks,
+      agent_knowledge: config.agentKnowledge
+    };
+    if (config.steps) {
+      request.steps = config.steps;
+    }
+    if (callbacks) {
+      let answerText = "";
+      let resolveMessages;
+      const messagesPromise = new Promise((resolve) => {
+        resolveMessages = resolve;
+      });
+      const wrappedCallbacks = {
+        ...callbacks,
+        onGeneration: (chunk) => {
+          answerText += chunk;
+          callbacks.onGeneration?.(chunk);
+        },
+        onDone: (data) => {
+          const updatedMessages2 = [
+            ...history,
+            { role: "user", content: userMessage },
+            { role: "assistant", content: answerText }
+          ];
+          callbacks.onAssistantMessage?.(answerText);
+          callbacks.onMessagesUpdated?.(updatedMessages2);
+          callbacks.onDone?.(data);
+          resolveMessages(updatedMessages2);
+        }
+      };
+      const abortController = await this.performRetrievalAgent(
+        request,
+        wrappedCallbacks
+      );
+      return { abortController, messages: messagesPromise };
+    }
+    const result = await this.performRetrievalAgent(request);
+    const updatedMessages = result.messages?.length ? result.messages : [
+      ...history,
+      { role: "user", content: userMessage },
+      ...result.generation ? [{ role: "assistant", content: result.generation }] : []
+    ];
+    return { result, messages: updatedMessages };
   }
   /**
    * Query Builder Agent - Translates natural language into structured search queries
@@ -787,146 +741,17 @@ var AntflyClient = class {
     return data;
   }
   /**
-   * Private helper for Chat Agent requests to handle streaming and non-streaming responses
+   * Standalone evaluation for testing evaluators without running a query.
+   * Evaluates a generated output against ground truth using LLM-as-judge metrics.
+   * @param request - Eval request with evaluators, judge config, query, output, and ground truth
+   * @returns Evaluation result with scores for each evaluator
    */
-  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
+  async evaluate(request) {
+    const { data, error } = await this.client.POST("/eval", {
+      body: request
     });
-    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(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);
+    if (error) throw new Error(`Evaluation failed: ${error.error}`);
+    return data;
   }
   /**
    * Get the underlying OpenAPI client for advanced use cases
@@ -1094,8 +919,11 @@ var generatorProviders = [
   "ollama",
   "gemini",
   "openai",
-  "bedrock",
-  "anthropic"
+  "anthropic",
+  "vertex",
+  "cohere",
+  "termite",
+  "openrouter"
 ];
 
 // src/index.ts