valyu-js 2.7.18 → 2.9.0

package/dist/index.mjs

@@ -3,7 +3,8 @@ import { createHmac, timingSafeEqual } from "crypto";
 import http from "http";
 import https from "https";
 import axios from "axios";
-var SDK_VERSION = "2.7.17";
+var SDK_VERSION = "2.9.0";
+var TRANSIENT_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
 function normalizeContentsJobResponse(api) {
   return {
     success: api.success ?? true,
@@ -94,6 +95,15 @@ var Valyu = class {
       list: this._datasourcesList.bind(this),
       categories: this._datasourcesCategories.bind(this)
     };
+    this.workflows = {
+      list: this._workflowsList.bind(this),
+      get: this._workflowsGet.bind(this),
+      versions: this._workflowsVersions.bind(this),
+      preview: this._workflowsPreview.bind(this),
+      create: this._workflowsCreate.bind(this),
+      update: this._workflowsUpdate.bind(this),
+      delete: this._workflowsDelete.bind(this)
+    };
   }
   /**
    * Validates date format (YYYY-MM-DD)
@@ -621,6 +631,41 @@ var Valyu = class {
   async _deepresearchCreate(options) {
     try {
       const queryValue = options.query ?? options.input;
+      if (options.workflowId) {
+        if (queryValue || options.strategy || options.researchStrategy || options.reportFormat) {
+          return {
+            success: false,
+            error: "workflowId is mutually exclusive with query/input/researchStrategy/reportFormat - the workflow template supplies those fields"
+          };
+        }
+        const payload2 = {
+          workflow_id: options.workflowId
+        };
+        if (options.workflowParams !== void 0) {
+          payload2.workflow_params = options.workflowParams;
+        }
+        if (options.workflowVersion !== void 0) {
+          payload2.workflow_version = options.workflowVersion;
+        }
+        const explicitMode = options.mode ?? options.model;
+        if (explicitMode) payload2.mode = explicitMode;
+        if (options.outputFormats) payload2.output_formats = options.outputFormats;
+        if (options.tools) payload2.tools = options.tools;
+        if (options.webhookUrl) payload2.webhook_url = options.webhookUrl;
+        if (options.alertEmail) {
+          payload2.alert_email = typeof options.alertEmail === "string" ? options.alertEmail : {
+            email: options.alertEmail.email,
+            custom_url: options.alertEmail.custom_url
+          };
+        }
+        if (options.metadata) payload2.metadata = options.metadata;
+        const response2 = await this.client.post(
+          `${this.baseUrl}/deepresearch/tasks`,
+          payload2,
+          { headers: this.headers }
+        );
+        return { success: true, ...response2.data };
+      }
       if (!queryValue?.trim()) {
         return {
           success: false,
@@ -744,19 +789,49 @@ var Valyu = class {
   /**
    * DeepResearch: Get task status
    */
-  async _deepresearchStatus(taskId) {
-    try {
-      const response = await this.client.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
-      };
+  async _deepresearchStatus(taskId, maxAttempts = 5) {
+    const url = `${this.baseUrl}/deepresearch/tasks/${taskId}/status`;
+    let lastError = "status endpoint unreachable";
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const response = await this.client.get(url, {
+          headers: this.headers,
+          // Classify status codes ourselves rather than letting axios throw.
+          validateStatus: () => true
+        });
+        if (TRANSIENT_STATUS_CODES.has(response.status)) {
+          lastError = `HTTP ${response.status}`;
+        } else {
+          const contentType = String(
+            response.headers?.["content-type"] || ""
+          );
+          const body = response.data;
+          const isJsonObject = contentType.toLowerCase().includes("application/json") && typeof body === "object" && body !== null && !Array.isArray(body);
+          if (!isJsonObject) {
+            lastError = `non-JSON/empty status response (HTTP ${response.status}, content-type: ${contentType || "none"})`;
+          } else if (response.status >= 400) {
+            return {
+              success: false,
+              error: body.error || `HTTP Error: ${response.status}`
+            };
+          } else {
+            const { success: _ignored, ...rest } = body;
+            return { success: true, ...rest };
+          }
+        }
+      } catch (e) {
+        lastError = e?.message || String(e);
+      }
+      if (attempt < maxAttempts - 1) {
+        const delayMs = Math.min(2 ** attempt, 30) * 1e3 + Math.random() * 1e3;
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
     }
+    return {
+      success: false,
+      unreachable: true,
+      error: `Status endpoint unreachable after ${maxAttempts} attempts: ${lastError}`
+    };
   }
   /**
    * DeepResearch: Wait for task completion with polling
@@ -768,6 +843,15 @@ var Valyu = class {
     while (true) {
       const status = await this._deepresearchStatus(taskId);
       if (!status.success) {
+        if (status.unreachable) {
+          if (Date.now() - startTime > maxWaitTime) {
+            throw new Error(
+              `Status endpoint unreachable for ${maxWaitTime}ms: ${status.error}`
+            );
+          }
+          await new Promise((resolve) => setTimeout(resolve, pollInterval));
+          continue;
+        }
         throw new Error(status.error);
       }
       if (options.onProgress) {
@@ -1639,6 +1723,160 @@ var Valyu = class {
       };
     }
   }
+  /** Extract the most descriptive error message from a Workflows API error. */
+  workflowError(e) {
+    return e.response?.data?.message || e.response?.data?.error || e.message;
+  }
+  /**
+   * Workflows: List workflows available to your org
+   * @param options - Filters: vertical, scope ("valyu" | "org" | "all"), q, tags, limit, expand
+   */
+  async _workflowsList(options = {}) {
+    try {
+      const params = new URLSearchParams();
+      if (options.vertical) params.append("vertical", options.vertical);
+      if (options.scope) params.append("scope", options.scope);
+      if (options.q) params.append("q", options.q);
+      if (options.tags?.length) params.append("tags", options.tags.join(","));
+      if (options.limit !== void 0) {
+        params.append("limit", String(options.limit));
+      }
+      if (options.expand) params.append("expand", "true");
+      const url = `${this.baseUrl}/workflows${params.toString() ? `?${params.toString()}` : ""}`;
+      const response = await this.client.get(url, { headers: this.headers });
+      return { success: true, ...response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
+  /**
+   * Workflows: Get a workflow's full detail, including its template
+   * @param slug - Workflow slug
+   * @param version - Specific version to fetch (defaults to the current version)
+   */
+  async _workflowsGet(slug, version) {
+    try {
+      const url = `${this.baseUrl}/workflows/${encodeURIComponent(slug)}${version !== void 0 ? `?version=${version}` : ""}`;
+      const response = await this.client.get(url, { headers: this.headers });
+      return { success: true, workflow: response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
+  /**
+   * Workflows: List a workflow's version history
+   * @param slug - Workflow slug
+   */
+  async _workflowsVersions(slug) {
+    try {
+      const response = await this.client.get(
+        `${this.baseUrl}/workflows/${encodeURIComponent(slug)}/versions`,
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
+  /**
+   * Workflows: Resolve a workflow's template with params without creating a task
+   * @param slug - Workflow slug
+   * @param options - workflowParams (variable values) and optional workflowVersion
+   */
+  async _workflowsPreview(slug, options = {}) {
+    try {
+      const payload = {};
+      if (options.workflowParams !== void 0) {
+        payload.workflow_params = options.workflowParams;
+      }
+      if (options.workflowVersion !== void 0) {
+        payload.workflow_version = options.workflowVersion;
+      }
+      const response = await this.client.post(
+        `${this.baseUrl}/workflows/${encodeURIComponent(slug)}/preview`,
+        payload,
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
+  /**
+   * Workflows: Create a new workflow for your org
+   * @param options - slug, title, version (template body), and optional metadata
+   */
+  async _workflowsCreate(options) {
+    try {
+      const payload = {
+        slug: options.slug,
+        title: options.title,
+        version: options.version
+      };
+      if (options.subtitle !== void 0) payload.subtitle = options.subtitle;
+      if (options.description !== void 0) {
+        payload.description = options.description;
+      }
+      if (options.vertical !== void 0) payload.vertical = options.vertical;
+      if (options.tags !== void 0) payload.tags = options.tags;
+      if (options.icon !== void 0) payload.icon = options.icon;
+      const response = await this.client.post(
+        `${this.baseUrl}/workflows`,
+        payload,
+        { headers: this.headers }
+      );
+      return { success: true, workflow: response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
+  /**
+   * Workflows: Update a workflow's metadata and/or publish a new template version.
+   * Only workflows owned by your org can be updated; versions are append-only
+   * (a version body requires a changelog).
+   * @param slug - Workflow slug
+   * @param options - Metadata fields and/or a new version body
+   */
+  async _workflowsUpdate(slug, options) {
+    try {
+      const payload = {};
+      if (options.title !== void 0) payload.title = options.title;
+      if (options.subtitle !== void 0) payload.subtitle = options.subtitle;
+      if (options.description !== void 0) {
+        payload.description = options.description;
+      }
+      if (options.vertical !== void 0) payload.vertical = options.vertical;
+      if (options.tags !== void 0) payload.tags = options.tags;
+      if (options.icon !== void 0) payload.icon = options.icon;
+      if (options.version !== void 0) payload.version = options.version;
+      if (options.setCurrent !== void 0) {
+        payload.set_current = options.setCurrent;
+      }
+      const response = await this.client.patch(
+        `${this.baseUrl}/workflows/${encodeURIComponent(slug)}`,
+        payload,
+        { headers: this.headers }
+      );
+      return { success: true, workflow: response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
+  /**
+   * Workflows: Delete a workflow owned by your org (soft delete)
+   * @param slug - Workflow slug
+   */
+  async _workflowsDelete(slug) {
+    try {
+      const response = await this.client.delete(
+        `${this.baseUrl}/workflows/${encodeURIComponent(slug)}`,
+        { headers: this.headers }
+      );
+      return { success: true, ...response.data };
+    } catch (e) {
+      return { success: false, error: this.workflowError(e) };
+    }
+  }
 };
 export {
   Valyu,