valyu-js 2.1.7 → 2.2.1

package/dist/index.mjs

@@ -13,6 +13,17 @@ var Valyu = class {
       "Content-Type": "application/json",
       "x-api-key": apiKey
     };
+    this.deepresearch = {
+      create: this._deepresearchCreate.bind(this),
+      status: this._deepresearchStatus.bind(this),
+      wait: this._deepresearchWait.bind(this),
+      stream: this._deepresearchStream.bind(this),
+      list: this._deepresearchList.bind(this),
+      update: this._deepresearchUpdate.bind(this),
+      cancel: this._deepresearchCancel.bind(this),
+      delete: this._deepresearchDelete.bind(this),
+      togglePublic: this._deepresearchTogglePublic.bind(this)
+    };
   }
   /**
    * Validates date format (YYYY-MM-DD)
@@ -432,177 +443,508 @@ var Valyu = class {
     }
   }
   /**
-   * Get AI-powered answers using the Valyu Answer API
-   * @param query - The question or query string
-   * @param options - Answer configuration options
-   * @param options.structuredOutput - JSON Schema object for structured responses
-   * @param options.systemInstructions - Custom system-level instructions (max 2000 chars)
-   * @param options.searchType - Type of search: "web", "proprietary", "all", or "news"
-   * @param options.dataMaxPrice - Maximum spend (USD) for data retrieval
-   * @param options.countryCode - Country code filter for search results
-   * @param options.includedSources - List of specific sources to include
-   * @param options.excludedSources - List of URLs/domains to exclude from search results
-   * @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
+   * DeepResearch: Create a new research task
    */
-  async answer(query, options = {}) {
+  async _deepresearchCreate(options) {
     try {
-      const defaultSearchType = "all";
-      if (!query || typeof query !== "string" || query.trim().length === 0) {
+      if (!options.input?.trim()) {
         return {
           success: false,
-          error: "Query is required and must be a non-empty string"
+          error: "input is required and cannot be empty"
         };
       }
-      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 payload = {
+        input: options.input,
+        model: options.model || "lite",
+        output_formats: options.outputFormats || ["markdown"],
+        code_execution: options.codeExecution !== false
+      };
+      if (options.strategy) payload.strategy = options.strategy;
+      if (options.search) {
+        payload.search = {
+          search_type: options.search.searchType,
+          included_sources: options.search.includedSources
         };
       }
-      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.urls) payload.urls = options.urls;
+      if (options.files) payload.files = options.files;
+      if (options.mcpServers) payload.mcp_servers = options.mcpServers;
+      if (options.previousReports) {
+        payload.previous_reports = options.previousReports;
+      }
+      if (options.webhookUrl) payload.webhook_url = options.webhookUrl;
+      if (options.metadata) payload.metadata = options.metadata;
+      const response = await axios.post(
+        `${this.baseUrl}/deepresearch/tasks`,
+        payload,
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
+      };
+    }
+  }
+  /**
+   * DeepResearch: Get task status
+   */
+  async _deepresearchStatus(taskId) {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/deepresearch/tasks/${taskId}/status`,
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
+      };
+    }
+  }
+  /**
+   * DeepResearch: Wait for task completion with polling
+   */
+  async _deepresearchWait(taskId, options = {}) {
+    const pollInterval = options.pollInterval || 5e3;
+    const maxWaitTime = options.maxWaitTime || 36e5;
+    const startTime = Date.now();
+    while (true) {
+      const status = await this._deepresearchStatus(taskId);
+      if (!status.success) {
+        throw new Error(status.error);
       }
-      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.onProgress) {
+        options.onProgress(status);
       }
-      if (options.startDate && !this.validateDateFormat(options.startDate)) {
-        return {
-          success: false,
-          error: "Invalid startDate format. Must be YYYY-MM-DD"
-        };
+      if (status.status === "completed" || status.status === "failed" || status.status === "cancelled") {
+        return status;
       }
-      if (options.endDate && !this.validateDateFormat(options.endDate)) {
-        return {
-          success: false,
-          error: "Invalid endDate format. Must be YYYY-MM-DD"
-        };
+      if (Date.now() - startTime > maxWaitTime) {
+        throw new Error("Maximum wait time exceeded");
       }
-      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"
-          };
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+  /**
+   * DeepResearch: Stream real-time updates
+   */
+  async _deepresearchStream(taskId, callback) {
+    let isComplete = false;
+    let lastMessageCount = 0;
+    while (!isComplete) {
+      try {
+        const status = await this._deepresearchStatus(taskId);
+        if (!status.success) {
+          if (callback.onError) {
+            callback.onError(new Error(status.error));
+          }
+          return;
         }
-      }
-      if (options.includedSources !== void 0) {
-        if (!Array.isArray(options.includedSources)) {
-          return {
-            success: false,
-            error: "includedSources must be an array"
-          };
+        if (status.progress && callback.onProgress) {
+          callback.onProgress(
+            status.progress.current_step,
+            status.progress.total_steps
+          );
         }
-        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 (status.messages && callback.onMessage) {
+          const newMessages = status.messages.slice(lastMessageCount);
+          newMessages.forEach((msg) => callback.onMessage(msg));
+          lastMessageCount = status.messages.length;
         }
-      }
-      if (options.excludedSources !== void 0) {
-        if (!Array.isArray(options.excludedSources)) {
-          return {
-            success: false,
-            error: "excludedSources must be an array"
-          };
+        if (status.status === "completed") {
+          if (callback.onComplete) {
+            callback.onComplete(status);
+          }
+          isComplete = true;
+        } else if (status.status === "failed" || status.status === "cancelled") {
+          if (callback.onError) {
+            callback.onError(
+              new Error(status.error || `Task ${status.status}`)
+            );
+          }
+          isComplete = true;
         }
-        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.`
-          };
+        if (!isComplete) {
+          await new Promise((resolve) => setTimeout(resolve, 5e3));
+        }
+      } catch (error) {
+        if (callback.onError) {
+          callback.onError(error);
         }
+        throw error;
       }
-      const payload = {
-        query: query.trim(),
-        search_type: finalSearchType
+    }
+  }
+  /**
+   * DeepResearch: List all tasks
+   */
+  async _deepresearchList(options) {
+    try {
+      const limit = options.limit || 10;
+      const response = await axios.get(
+        `${this.baseUrl}/deepresearch/listtasks?api_key_id=${options.apiKeyId}&limit=${limit}`,
+        { headers: this.headers }
+      );
+      return { success: true, data: response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
+      };
+    }
+  }
+  /**
+   * DeepResearch: Add follow-up instruction
+   */
+  async _deepresearchUpdate(taskId, instruction) {
+    try {
+      if (!instruction?.trim()) {
+        return {
+          success: false,
+          error: "instruction is required and cannot be empty"
+        };
+      }
+      const response = await axios.post(
+        `${this.baseUrl}/deepresearch/tasks/${taskId}/update`,
+        { instruction },
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
+      };
+    }
+  }
+  /**
+   * DeepResearch: Cancel task
+   */
+  async _deepresearchCancel(taskId) {
+    try {
+      const response = await axios.post(
+        `${this.baseUrl}/deepresearch/tasks/${taskId}/cancel`,
+        {},
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
+      };
+    }
+  }
+  /**
+   * DeepResearch: Delete task
+   */
+  async _deepresearchDelete(taskId) {
+    try {
+      const response = await axios.delete(
+        `${this.baseUrl}/deepresearch/tasks/${taskId}/delete`,
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
       };
-      if (options.dataMaxPrice !== void 0) {
-        payload.data_max_price = options.dataMaxPrice;
+    }
+  }
+  /**
+   * DeepResearch: Toggle public flag
+   */
+  async _deepresearchTogglePublic(taskId, isPublic) {
+    try {
+      const response = await axios.post(
+        `${this.baseUrl}/deepresearch/tasks/${taskId}/public`,
+        { public: isPublic },
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return {
+        success: false,
+        error: e.response?.data?.error || e.message
+      };
+    }
+  }
+  /**
+   * Get AI-powered answers using the Valyu Answer API
+   * @param query - The question or query string
+   * @param options - Answer configuration options
+   * @param options.structuredOutput - JSON Schema object for structured responses
+   * @param options.systemInstructions - Custom system-level instructions (max 2000 chars)
+   * @param options.searchType - Type of search: "web", "proprietary", "all", or "news"
+   * @param options.dataMaxPrice - Maximum spend (USD) for data retrieval
+   * @param options.countryCode - Country code filter for search results
+   * @param options.includedSources - List of specific sources to include
+   * @param options.excludedSources - List of URLs/domains to exclude from search results
+   * @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)
+   * @param options.streaming - Enable streaming mode (default: false)
+   * @returns Promise resolving to answer response, or AsyncGenerator for streaming
+   */
+  async answer(query, options = {}) {
+    const validationError = this.validateAnswerParams(query, options);
+    if (validationError) {
+      if (options.streaming) {
+        return this.createErrorGenerator(validationError);
       }
-      if (options.structuredOutput !== void 0) {
-        payload.structured_output = options.structuredOutput;
+      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.systemInstructions !== void 0) {
-        payload.system_instructions = options.systemInstructions.trim();
+      const trimmed = options.systemInstructions.trim();
+      if (trimmed.length === 0) {
+        return "systemInstructions cannot be empty when provided";
       }
-      if (options.countryCode !== void 0) {
-        payload.country_code = options.countryCode;
+      if (trimmed.length > 2e3) {
+        return "systemInstructions must be 2000 characters or less";
       }
-      if (options.includedSources !== void 0) {
-        payload.included_sources = options.includedSources;
+    }
+    if (options.dataMaxPrice !== void 0) {
+      if (typeof options.dataMaxPrice !== "number" || options.dataMaxPrice <= 0) {
+        return "dataMaxPrice must be a positive number";
       }
-      if (options.excludedSources !== void 0) {
-        payload.excluded_sources = options.excludedSources;
+    }
+    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.startDate !== void 0) {
-        payload.start_date = options.startDate;
+    }
+    if (options.includedSources !== void 0) {
+      if (!Array.isArray(options.includedSources)) {
+        return "includedSources must be an array";
       }
-      if (options.endDate !== void 0) {
-        payload.end_date = options.endDate;
+      const validation = this.validateSources(options.includedSources);
+      if (!validation.valid) {
+        return `Invalid includedSources format. Invalid sources: ${validation.invalidSources.join(", ")}.`;
       }
-      if (options.fastMode !== void 0) {
-        payload.fast_mode = options.fastMode;
+    }
+    if (options.excludedSources !== void 0) {
+      if (!Array.isArray(options.excludedSources)) {
+        return "excludedSources must be an array";
       }
-      const response = await axios.post(`${this.baseUrl}/answer`, payload, {
-        headers: this.headers
+      const validation = this.validateSources(options.excludedSources);
+      if (!validation.valid) {
+        return `Invalid excludedSources format. Invalid sources: ${validation.invalidSources.join(", ")}.`;
+      }
+    }
+    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;
+        return {
+          success: true,
+          ai_tx_id: finalMetadata.ai_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 }
+        };
+      }
+      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",
+                ai_tx_id: parsed.ai_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
+              };
+            }
+          } 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