valyu-js 2.2.0 → 2.2.2

package/dist/index.mjs

@@ -687,164 +687,269 @@ var Valyu = class {
    * @param options.startDate - Start date filter (YYYY-MM-DD format)
    * @param options.endDate - End date filter (YYYY-MM-DD format)
    * @param options.fastMode - Fast mode for quicker but shorter results (default: false)
-   * @returns Promise resolving to answer response
+   * @param options.streaming - Enable streaming mode (default: false)
+   * @returns Promise resolving to answer response, or AsyncGenerator for streaming
    */
   async answer(query, options = {}) {
-    try {
-      const defaultSearchType = "all";
-      if (!query || typeof query !== "string" || query.trim().length === 0) {
-        return {
-          success: false,
-          error: "Query is required and must be a non-empty string"
-        };
-      }
-      let finalSearchType = defaultSearchType;
-      const providedSearchTypeString = options.searchType?.toLowerCase();
-      if (providedSearchTypeString === "web" || providedSearchTypeString === "proprietary" || providedSearchTypeString === "all" || providedSearchTypeString === "news") {
-        finalSearchType = providedSearchTypeString;
-      } else if (options.searchType !== void 0) {
-        return {
-          success: false,
-          error: "Invalid searchType provided. Must be one of: all, web, proprietary, news"
-        };
+    const validationError = this.validateAnswerParams(query, options);
+    if (validationError) {
+      if (options.streaming) {
+        return this.createErrorGenerator(validationError);
       }
-      if (options.systemInstructions !== void 0) {
-        if (typeof options.systemInstructions !== "string") {
-          return {
-            success: false,
-            error: "systemInstructions must be a string"
-          };
-        }
-        const trimmed = options.systemInstructions.trim();
-        if (trimmed.length === 0) {
-          return {
-            success: false,
-            error: "systemInstructions cannot be empty when provided"
-          };
-        }
-        if (trimmed.length > 2e3) {
-          return {
-            success: false,
-            error: "systemInstructions must be 2000 characters or less"
-          };
-        }
-      }
-      if (options.dataMaxPrice !== void 0) {
-        if (typeof options.dataMaxPrice !== "number" || options.dataMaxPrice <= 0) {
-          return {
-            success: false,
-            error: "dataMaxPrice must be a positive number"
-          };
-        }
-      }
-      if (options.startDate && !this.validateDateFormat(options.startDate)) {
-        return {
-          success: false,
-          error: "Invalid startDate format. Must be YYYY-MM-DD"
-        };
-      }
-      if (options.endDate && !this.validateDateFormat(options.endDate)) {
-        return {
-          success: false,
-          error: "Invalid endDate format. Must be YYYY-MM-DD"
-        };
-      }
-      if (options.startDate && options.endDate) {
-        const startDate = new Date(options.startDate);
-        const endDate = new Date(options.endDate);
-        if (startDate > endDate) {
-          return {
-            success: false,
-            error: "startDate must be before endDate"
-          };
-        }
-      }
-      if (options.includedSources !== void 0) {
-        if (!Array.isArray(options.includedSources)) {
-          return {
-            success: false,
-            error: "includedSources must be an array"
-          };
-        }
-        const includedSourcesValidation = this.validateSources(
-          options.includedSources
-        );
-        if (!includedSourcesValidation.valid) {
-          return {
-            success: false,
-            error: `Invalid includedSources format. Invalid sources: ${includedSourcesValidation.invalidSources.join(
-              ", "
-            )}. Sources must be valid URLs, domains (with optional paths), or dataset identifiers in 'provider/dataset' format.`
-          };
-        }
-      }
-      if (options.excludedSources !== void 0) {
-        if (!Array.isArray(options.excludedSources)) {
-          return {
-            success: false,
-            error: "excludedSources must be an array"
-          };
-        }
-        const excludedSourcesValidation = this.validateSources(
-          options.excludedSources
-        );
-        if (!excludedSourcesValidation.valid) {
-          return {
-            success: false,
-            error: `Invalid excludedSources format. Invalid sources: ${excludedSourcesValidation.invalidSources.join(
-              ", "
-            )}. Sources must be valid URLs, domains (with optional paths), or dataset identifiers in 'provider/dataset' format.`
-          };
-        }
-      }
-      const payload = {
-        query: query.trim(),
-        search_type: finalSearchType
-      };
-      if (options.dataMaxPrice !== void 0) {
-        payload.data_max_price = options.dataMaxPrice;
+      return { success: false, error: validationError };
+    }
+    const payload = this.buildAnswerPayload(query, options);
+    if (options.streaming) {
+      return this.streamAnswer(payload);
+    } else {
+      return this.fetchAnswer(payload);
+    }
+  }
+  /**
+   * Validate answer parameters
+   */
+  validateAnswerParams(query, options) {
+    if (!query || typeof query !== "string" || query.trim().length === 0) {
+      return "Query is required and must be a non-empty string";
+    }
+    const providedSearchTypeString = options.searchType?.toLowerCase();
+    if (providedSearchTypeString !== void 0 && providedSearchTypeString !== "web" && providedSearchTypeString !== "proprietary" && providedSearchTypeString !== "all" && providedSearchTypeString !== "news") {
+      return "Invalid searchType provided. Must be one of: all, web, proprietary, news";
+    }
+    if (options.systemInstructions !== void 0) {
+      if (typeof options.systemInstructions !== "string") {
+        return "systemInstructions must be a string";
       }
-      if (options.structuredOutput !== void 0) {
-        payload.structured_output = options.structuredOutput;
+      const trimmed = options.systemInstructions.trim();
+      if (trimmed.length === 0) {
+        return "systemInstructions cannot be empty when provided";
       }
-      if (options.systemInstructions !== void 0) {
-        payload.system_instructions = options.systemInstructions.trim();
+      if (trimmed.length > 2e3) {
+        return "systemInstructions must be 2000 characters or less";
       }
-      if (options.countryCode !== void 0) {
-        payload.country_code = options.countryCode;
+    }
+    if (options.dataMaxPrice !== void 0) {
+      if (typeof options.dataMaxPrice !== "number" || options.dataMaxPrice <= 0) {
+        return "dataMaxPrice must be a positive number";
       }
-      if (options.includedSources !== void 0) {
-        payload.included_sources = options.includedSources;
+    }
+    if (options.startDate && !this.validateDateFormat(options.startDate)) {
+      return "Invalid startDate format. Must be YYYY-MM-DD";
+    }
+    if (options.endDate && !this.validateDateFormat(options.endDate)) {
+      return "Invalid endDate format. Must be YYYY-MM-DD";
+    }
+    if (options.startDate && options.endDate) {
+      const startDate = new Date(options.startDate);
+      const endDate = new Date(options.endDate);
+      if (startDate > endDate) {
+        return "startDate must be before endDate";
       }
-      if (options.excludedSources !== void 0) {
-        payload.excluded_sources = options.excludedSources;
+    }
+    if (options.includedSources !== void 0) {
+      if (!Array.isArray(options.includedSources)) {
+        return "includedSources must be an array";
       }
-      if (options.startDate !== void 0) {
-        payload.start_date = options.startDate;
+      const validation = this.validateSources(options.includedSources);
+      if (!validation.valid) {
+        return `Invalid includedSources format. Invalid sources: ${validation.invalidSources.join(", ")}.`;
       }
-      if (options.endDate !== void 0) {
-        payload.end_date = options.endDate;
+    }
+    if (options.excludedSources !== void 0) {
+      if (!Array.isArray(options.excludedSources)) {
+        return "excludedSources must be an array";
       }
-      if (options.fastMode !== void 0) {
-        payload.fast_mode = options.fastMode;
+      const validation = this.validateSources(options.excludedSources);
+      if (!validation.valid) {
+        return `Invalid excludedSources format. Invalid sources: ${validation.invalidSources.join(", ")}.`;
       }
-      const response = await axios.post(`${this.baseUrl}/answer`, payload, {
-        headers: this.headers
+    }
+    return null;
+  }
+  /**
+   * Build payload for answer API
+   */
+  buildAnswerPayload(query, options) {
+    const defaultSearchType = "all";
+    const providedSearchTypeString = options.searchType?.toLowerCase();
+    let finalSearchType = defaultSearchType;
+    if (providedSearchTypeString === "web" || providedSearchTypeString === "proprietary" || providedSearchTypeString === "all" || providedSearchTypeString === "news") {
+      finalSearchType = providedSearchTypeString;
+    }
+    const payload = {
+      query: query.trim(),
+      search_type: finalSearchType
+    };
+    if (options.dataMaxPrice !== void 0) payload.data_max_price = options.dataMaxPrice;
+    if (options.structuredOutput !== void 0) payload.structured_output = options.structuredOutput;
+    if (options.systemInstructions !== void 0) payload.system_instructions = options.systemInstructions.trim();
+    if (options.countryCode !== void 0) payload.country_code = options.countryCode;
+    if (options.includedSources !== void 0) payload.included_sources = options.includedSources;
+    if (options.excludedSources !== void 0) payload.excluded_sources = options.excludedSources;
+    if (options.startDate !== void 0) payload.start_date = options.startDate;
+    if (options.endDate !== void 0) payload.end_date = options.endDate;
+    if (options.fastMode !== void 0) payload.fast_mode = options.fastMode;
+    return payload;
+  }
+  /**
+   * Fetch answer (non-streaming mode)
+   */
+  async fetchAnswer(payload) {
+    try {
+      const response = await fetch(`${this.baseUrl}/answer`, {
+        method: "POST",
+        headers: {
+          ...this.headers,
+          "Accept": "text/event-stream"
+        },
+        body: JSON.stringify(payload)
       });
-      if (!response.status || response.status < 200 || response.status >= 300) {
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
         return {
           success: false,
-          error: response.data?.error || "Request failed"
+          error: errorData.error || `HTTP Error: ${response.status}`
         };
       }
-      return response.data;
+      let fullContent = "";
+      let searchResults = [];
+      let finalMetadata = {};
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      if (reader) {
+        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.startsWith("data: ")) continue;
+            const dataStr = line.slice(6);
+            if (dataStr === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(dataStr);
+              if (parsed.search_results && !parsed.success) {
+                searchResults = [...searchResults, ...parsed.search_results];
+              } else if (parsed.choices) {
+                const content = parsed.choices[0]?.delta?.content || "";
+                if (content) fullContent += content;
+              } else if (parsed.success !== void 0) {
+                finalMetadata = parsed;
+              }
+            } catch {
+              continue;
+            }
+          }
+        }
+      }
+      if (finalMetadata.success) {
+        const finalSearchResults = finalMetadata.search_results || searchResults;
+        const response2 = {
+          success: true,
+          tx_id: finalMetadata.tx_id || "",
+          original_query: finalMetadata.original_query || payload.query,
+          contents: fullContent || finalMetadata.contents || "",
+          data_type: finalMetadata.data_type || "unstructured",
+          search_results: finalSearchResults,
+          search_metadata: finalMetadata.search_metadata || { tx_ids: [], number_of_results: 0, total_characters: 0 },
+          ai_usage: finalMetadata.ai_usage || { input_tokens: 0, output_tokens: 0 },
+          cost: finalMetadata.cost || { total_deduction_dollars: 0, search_deduction_dollars: 0, ai_deduction_dollars: 0 }
+        };
+        if (finalMetadata.extraction_metadata) {
+          response2.extraction_metadata = finalMetadata.extraction_metadata;
+        }
+        return response2;
+      }
+      return {
+        success: false,
+        error: finalMetadata.error || "Unknown error occurred"
+      };
     } catch (e) {
       return {
         success: false,
-        error: e.response?.data?.error || e.message
+        error: e.message || "Request failed"
       };
     }
   }
+  /**
+   * Stream answer using SSE
+   */
+  async *streamAnswer(payload) {
+    try {
+      const response = await fetch(`${this.baseUrl}/answer`, {
+        method: "POST",
+        headers: {
+          ...this.headers,
+          "Accept": "text/event-stream"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        yield { type: "error", error: errorData.error || `HTTP Error: ${response.status}` };
+        return;
+      }
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      if (!reader) {
+        yield { type: "error", error: "No response body" };
+        return;
+      }
+      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.startsWith("data: ")) continue;
+          const dataStr = line.slice(6);
+          if (dataStr === "[DONE]") {
+            yield { type: "done" };
+            continue;
+          }
+          try {
+            const parsed = JSON.parse(dataStr);
+            if (parsed.search_results && parsed.success === void 0) {
+              yield { type: "search_results", search_results: parsed.search_results };
+            } else if (parsed.choices) {
+              const delta = parsed.choices[0]?.delta || {};
+              const content = delta.content || "";
+              const finishReason = parsed.choices[0]?.finish_reason;
+              if (content || finishReason) {
+                yield { type: "content", content, finish_reason: finishReason };
+              }
+            } else if (parsed.success !== void 0) {
+              yield {
+                type: "metadata",
+                tx_id: parsed.tx_id,
+                original_query: parsed.original_query,
+                data_type: parsed.data_type,
+                search_results: parsed.search_results,
+                search_metadata: parsed.search_metadata,
+                ai_usage: parsed.ai_usage,
+                cost: parsed.cost,
+                extraction_metadata: parsed.extraction_metadata
+              };
+            }
+          } catch {
+            continue;
+          }
+        }
+      }
+    } catch (e) {
+      yield { type: "error", error: e.message || "Stream failed" };
+    }
+  }
+  /**
+   * Create an error generator for streaming errors
+   */
+  async *createErrorGenerator(error) {
+    yield { type: "error", error };
+  }
 };
 export {
   Valyu