@golpoai/sdk 0.1.9 → 1.0.0

package/dist/index.cjs

@@ -57,33 +57,55 @@ var Golpo = class {
   async createPodcastJob(prompt, opts = {}) {
     const {
       uploads,
-      concurrency = 8,
-      addMusic = false,
       voiceInstructions,
-      personality1,
-      personality2,
-      doResearch = false,
-      ttsModel = "accurate",
       language,
-      style = "conversational",
+      style = "solo-female-3",
       bgMusic,
-      outputVolume = 1,
-      no_voice_chunking = false
+      // Extended params
+      newScript,
+      timing = 1
+      // timing in minutes – default 1 if not provided
     } = opts;
+    const concurrency = 8;
     const fields = [
       ["prompt", prompt],
-      ["add_music", String(addMusic)],
-      ["do_research", String(doResearch)],
-      ["tts_model", ttsModel],
-      ["style", style],
-      ["output_volume", String(outputVolume)]
+      ["style", style]
     ];
     if (voiceInstructions) fields.push(["voice_instructions", voiceInstructions]);
-    if (personality1) fields.push(["personality_1", personality1]);
-    if (personality2) fields.push(["personality_2", personality2]);
     if (language) fields.push(["language", language]);
     if (bgMusic) fields.push(["bg_music", bgMusic]);
-    if (no_voice_chunking) fields.push(["no_voice_chunking", String(no_voice_chunking)]);
+    if (newScript != null) fields.push(["new_script", newScript]);
+    fields.push(["timing", String(timing)]);
+    fields.push(["video_type", "null"]);
+    const hasUploads = (() => {
+      if (!uploads) return false;
+      if (typeof uploads === "string") return uploads.trim().length > 0;
+      const iterator = uploads[Symbol.iterator]();
+      const first = iterator.next();
+      return !first.done;
+    })();
+    const request_payload = {
+      prompt,
+      video_voice: style,
+      video_duration: String(timing),
+      video_type: "null",
+      language,
+      voice_instructions: voiceInstructions,
+      new_script: newScript,
+      bg_music: bgMusic,
+      attached_documents: uploads,
+      source: "node-sdk"
+    };
+    try {
+      const result = await this.createVideoRecord({
+        topic: prompt,
+        requestPayload: request_payload
+      });
+      if (result && result.videoId) {
+        fields.push(["video_id", result.videoId]);
+      }
+    } catch (error) {
+    }
     const formData = await this.createFormData(fields, uploads, concurrency);
     const { data } = await this.http.post("/generate", formData, {
       timeout: 24e4,
@@ -110,63 +132,210 @@ var Golpo = class {
   async createPodcast(prompt, opts = {}) {
     const { pollIntervalMs = 2e3, ...jobOpts } = opts;
     const jobId = await this.createPodcastJob(prompt, jobOpts);
-    return this.pollUntilComplete(
+    const r = await this.pollUntilComplete(
       jobId,
       pollIntervalMs
-    ).then((r) => ({
-      podcastUrl: r.podcast_url,
-      podcastScript: r.podcast_script
-    }));
+    );
+    return { url: r.podcast_url, script: r.podcast_script, videoId: jobId };
   }
   async createVideo(prompt, opts = {}) {
     const {
       uploads,
       pollIntervalMs = 2e3,
-      concurrency = 8,
       voiceInstructions,
-      personality1,
-      doResearch = false,
-      ttsModel = "accurate",
       language,
-      style = "solo-female",
+      style = "solo-female-3",
       bgMusic = "engaging",
-      bgVolume = 1.4,
-      outputVolume = 1,
       videoType = "long",
-      includeWatermark = true,
+      includeWatermark = false,
       logo,
-      timing = "1"
+      timing = 1,
+      useColor = true,
+      // newly added backend parameters
+      newScript,
+      logoPlacement,
+      videoInstructions,
+      useLineart2Style,
+      audioClip,
+      isPublic,
+      useAsIs,
+      skipAnimation,
+      userImages,
+      userImagesDescriptions,
+      userVideos,
+      userVideosDescription,
+      userAudioInVideo,
+      use2Style,
+      // specificAnimation, // not yet supported by the Golpo 2.0 pipeline
+      imageStyle,
+      inputImages,
+      penStyle,
+      showPencilCursor,
+      pacing,
+      justReturnScript
     } = opts;
+    const concurrency = 8;
+    const request_payload = {
+      prompt,
+      video_voice: style,
+      video_duration: String(timing),
+      video_type: videoType,
+      language,
+      voice_instructions: voiceInstructions,
+      bg_music: bgMusic,
+      use_color: useColor,
+      direct_script: newScript,
+      script_mode: newScript ? true : false,
+      logo_placement: logoPlacement,
+      video_instructions: videoInstructions,
+      use_lineart_2_style: useLineart2Style,
+      audio_clip: audioClip,
+      is_public: isPublic,
+      use_as_is: useAsIs,
+      skip_animation: skipAnimation,
+      user_images: userImages,
+      user_images_descriptions: userImagesDescriptions,
+      user_videos: userVideos,
+      user_videos_description: userVideosDescription,
+      user_audio_in_video: userAudioInVideo,
+      use_2_0_style: use2Style,
+      // specific_animation: specificAnimation, // not yet supported by the pipeline
+      image_style: imageStyle,
+      input_images: inputImages,
+      pen_style: penStyle,
+      show_pencil_cursor: penStyle ? true : showPencilCursor ?? false,
+      pacing,
+      own_narration_video_mode: null,
+      own_narration_pip_position: null,
+      just_return_script: justReturnScript,
+      attached_documents: uploads,
+      source: "node-sdk"
+    };
     const fields = [
       ["prompt", prompt],
-      ["do_research", String(doResearch)],
-      ["tts_model", ttsModel],
-      ["bg_volume", String(bgVolume)],
-      ["output_volume", String(outputVolume)],
       ["style", style],
       ["video_type", videoType],
       ["include_watermark", String(includeWatermark)],
-      ["timing", timing]
+      ["timing", String(timing)],
+      ["use_color", String(useColor)]
     ];
     if (language) fields.push(["language", language]);
     if (voiceInstructions) fields.push(["voice_instructions", voiceInstructions]);
-    if (personality1) fields.push(["personality_1", personality1]);
     if (bgMusic) fields.push(["bg_music", bgMusic]);
+    try {
+      const result = await this.createVideoRecord({
+        topic: prompt,
+        requestPayload: request_payload
+      });
+      if (result && result.videoId) {
+        fields.push(["video_id", result.videoId]);
+      }
+    } catch (error) {
+    }
+    if (newScript) fields.push(["new_script", newScript]);
+    if (logoPlacement) fields.push(["logo_placement", logoPlacement]);
+    if (videoInstructions) fields.push(["video_instructions", videoInstructions]);
+    if (useLineart2Style) fields.push(["use_lineart_2_style", useLineart2Style]);
+    if (isPublic != null) fields.push(["is_public", String(isPublic)]);
+    if (useAsIs) {
+      const value = Array.isArray(useAsIs) ? JSON.stringify(useAsIs) : useAsIs;
+      fields.push(["use_as_is", value]);
+    }
+    if (skipAnimation) {
+      const value = Array.isArray(skipAnimation) ? JSON.stringify(skipAnimation) : skipAnimation;
+      fields.push(["skip_animation", value]);
+    }
+    if (userImagesDescriptions) {
+      const value = Array.isArray(userImagesDescriptions) ? JSON.stringify(userImagesDescriptions) : userImagesDescriptions;
+      fields.push(["user_images_descriptions", value]);
+    }
+    if (userVideosDescription) {
+      const value = Array.isArray(userVideosDescription) ? JSON.stringify(userVideosDescription) : userVideosDescription;
+      fields.push(["user_videos_description", value]);
+    }
+    if (userAudioInVideo) {
+      fields.push(["user_audio_in_video", userAudioInVideo]);
+    } else if (userVideos) {
+      fields.push(["user_audio_in_video", "[]"]);
+    }
+    if (use2Style != null) fields.push(["use_2_0_style", String(use2Style)]);
+    if (imageStyle) fields.push(["image_style", imageStyle]);
+    if (penStyle) fields.push(["pen_style", penStyle]);
+    const effectiveShowPencilCursor = penStyle ? true : showPencilCursor ?? false;
+    fields.push(["show_pencil_cursor", String(effectiveShowPencilCursor)]);
+    if (pacing) fields.push(["pacing", pacing]);
+    if (justReturnScript != null) fields.push(["just_return_script", String(justReturnScript)]);
     if (logo) {
       fields.push(["logo_path", logo]);
     }
-    const formData = await this.createFormData(fields, uploads, concurrency, logo);
+    const formData = await this.createFormData(
+      fields,
+      uploads,
+      concurrency,
+      logo,
+      audioClip,
+      userImages,
+      userVideos,
+      inputImages
+    );
     const { data } = await this.http.post("/generate", formData, {
       timeout: 24e4,
       headers: formData.getHeaders()
     });
-    return this.pollUntilComplete(
+    if (justReturnScript) {
+      const r2 = await this.pollUntilComplete(
+        data.job_id,
+        pollIntervalMs,
+        "/script-status"
+      );
+      return { url: "", script: r2.podcast_script, videoId: data.job_id };
+    }
+    const r = await this.pollUntilComplete(
       data.job_id,
       pollIntervalMs
-    ).then((r) => ({
-      videoUrl: r.podcast_url,
-      videoScript: r.podcast_script
-    }));
+    );
+    return { url: r.podcast_url, script: r.podcast_script, videoId: data.job_id };
+  }
+  /**
+   * Private helper: Get user email from API key
+   * Backend resolves: api_key -> user_id -> user_credits.email
+   */
+  async getUserEmailFromApiKey() {
+    try {
+      const { data } = await this.http.get("/api/resolve-email-from-api-key");
+      return data.email || null;
+    } catch (error) {
+      return null;
+    }
+  }
+  async createVideoRecord(opts) {
+    const {
+      topic,
+      context = "",
+      scenes = 6,
+      pipeline = "color",
+      shareDocuments = false,
+      logoPlacement = null,
+      audioClipUrl = null,
+      requestPayload
+    } = opts;
+    const emailFromApiKey = await this.getUserEmailFromApiKey();
+    if (!emailFromApiKey) {
+      throw new Error("Email not found");
+    }
+    const body = {
+      topic,
+      context,
+      scenes,
+      pipeline,
+      user_email: emailFromApiKey,
+      share_documents: shareDocuments,
+      logo_placement: logoPlacement,
+      audio_clip_url: audioClipUrl,
+      request_payload: requestPayload ? JSON.stringify(requestPayload) : null
+    };
+    const { data } = await this.http.post("/api/create-video-record", body);
+    return { videoId: data.video_id };
   }
   /**
    * Edit specific frames of a video and regenerate the video.
@@ -213,11 +382,11 @@ var Golpo = class {
     try {
       const frameVersions = await this.getFrameVersions(videoId);
       let frameAnimations = frameVersions.frame_animations ? { ...frameVersions.frame_animations } : {};
-      frameIds.forEach(async (frameId) => {
+      for (const frameId of frameIds) {
         await this.setFrameVersion(videoId, frameId, editResult);
         const updatedVersions = await this.getFrameVersions(videoId);
         frameAnimations = updatedVersions.frame_animations || {};
-      });
+      }
       const mp4Urls = Object.entries(frameAnimations).sort(([a], [b]) => parseInt(a) - parseInt(b)).map(([_, url]) => url);
       if (mp4Urls.length === 0) {
         throw new Error("No frame animations found to combine");
@@ -227,17 +396,11 @@ var Golpo = class {
         pollIntervalMs,
         videoUrl
       };
-      const combinedUrl = await this.combineVideos(combineOptions);
-      return {
-        videoUrl: combinedUrl,
-        jobId
-      };
+      const combined = await this.combineVideos(combineOptions);
+      return { videoUrl: combined.url, jobId };
     } catch (error) {
       console.warn("Failed to auto-combine videos, returning edit result:", error);
-      return {
-        videoUrl: editResult,
-        jobId
-      };
+      return { videoUrl: editResult, jobId };
     }
   }
   /**
@@ -391,19 +554,25 @@ var Golpo = class {
     if (!combineJobId) {
       throw new Error("No job ID received from combine-videos API");
     }
-    return this.pollEditStatus(combineJobId, pollIntervalMs);
+    const url = await this.pollEditStatus(combineJobId, pollIntervalMs);
+    return { url };
   }
   /* ------------------------------------------------------------ *
    * INTERNAL HELPERS
    * ------------------------------------------------------------ */
-  async pollUntilComplete(jobId, interval) {
+  async pollUntilComplete(jobId, interval, statusPath = "/status") {
     while (true) {
+      let data;
       try {
-        const { data } = await this.http.get(`/status/${jobId}`);
-        if (data.status === "completed") return data;
+        const res = await this.http.get(`${statusPath}/${jobId}`);
+        data = res.data;
       } catch (error) {
         console.warn(`Status check failed for job ${jobId}, retrying in ${interval}ms:`, error instanceof Error ? error.message : error);
       }
+      if (data?.status === "completed") return data;
+      if (data?.status === "failed") {
+        throw new Error(`Job ${jobId} failed: ${data.error || data.message || "unknown error"}`);
+      }
       await new Promise((r) => setTimeout(r, interval));
     }
   }
@@ -453,7 +622,50 @@ var Golpo = class {
       attempts++;
     }
   }
-  async createFormData(fields, uploads, concurrency, logo) {
+  /**
+   * Upload a file using /upload-url endpoint and return the final URL.
+   * Replicates the _presign_and_upload_one logic from the backend.
+   */
+  async uploadFileAndGetUrl(filePath) {
+    const absPath = (0, import_path.resolve)(filePath.trim().replace(/^<|>$/g, ""));
+    try {
+      await import_fs.promises.access(absPath);
+    } catch (error) {
+      throw new Error(`File not found: ${absPath}. Original path: ${filePath}`);
+    }
+    const fileName = (0, import_path.basename)(absPath);
+    const fileData = await import_fs.promises.readFile(absPath);
+    const mimeType = (0, import_mime_types.lookup)(absPath) || "application/octet-stream";
+    const { data: presignInfo } = await this.http.post(
+      "/upload-url",
+      { filename: fileName },
+      { headers: { "Content-Type": "application/x-www-form-urlencoded" } }
+    );
+    let finalUrl;
+    if (presignInfo.url && presignInfo.fields) {
+      const uploadFormData = new import_form_data.default();
+      Object.entries(presignInfo.fields).forEach(([key, value]) => {
+        uploadFormData.append(key, value);
+      });
+      uploadFormData.append("file", fileData, { filename: fileName });
+      await import_axios.default.post(presignInfo.url, uploadFormData, {
+        headers: uploadFormData.getHeaders(),
+        timeout: 3e4
+      });
+      finalUrl = presignInfo.final_url || presignInfo.url.split("?")[0];
+    } else if (presignInfo.upload_url || presignInfo.url) {
+      const uploadUrl = presignInfo.upload_url || presignInfo.url;
+      await import_axios.default.put(uploadUrl, fileData, {
+        headers: { "Content-Type": mimeType },
+        timeout: 3e4
+      });
+      finalUrl = presignInfo.final_url || uploadUrl.split("?")[0];
+    } else {
+      throw new Error(`Unrecognized presign response: ${JSON.stringify(presignInfo)}`);
+    }
+    return finalUrl;
+  }
+  async createFormData(fields, uploads, concurrency, logo, audioClip, userImages, userVideos, inputImages) {
     const formData = new import_form_data.default();
     fields.forEach(([key, value]) => {
       if (key !== "logo_path") {
@@ -462,16 +674,147 @@ var Golpo = class {
     });
     if (logo) {
       const logoPath = logo.trim().replace(/^<|>$/g, "");
+      let logoUrl;
       if (URL_RE.test(logoPath)) {
-        throw new Error("URL uploads not supported for logo - only local file paths are accepted");
+        logoUrl = logoPath;
+      } else {
+        logoUrl = await this.uploadFileAndGetUrl(logoPath);
+      }
+      formData.append("logo", logoUrl);
+    }
+    if (audioClip) {
+      const audioList = Array.isArray(audioClip) ? audioClip : [audioClip];
+      const audioLocalFiles = [];
+      const audioUrls = [];
+      audioList.forEach((item) => {
+        const path = String(item).trim().replace(/^<|>$/g, "");
+        if (URL_RE.test(path)) {
+          audioUrls.push(path);
+        } else {
+          audioLocalFiles.push(path);
+        }
+      });
+      if (audioLocalFiles.length > 0) {
+        const limit = (0, import_p_limit.default)(concurrency);
+        const uploadedUrls = await Promise.all(
+          audioLocalFiles.map(
+            (filePath) => limit(() => this.uploadFileAndGetUrl(filePath))
+          )
+        );
+        audioUrls.push(...uploadedUrls);
+      }
+      if (audioUrls.length > 0) {
+        formData.append("audio_clip", audioUrls[0]);
+      }
+    }
+    if (userImages) {
+      const imagesList = Array.isArray(userImages) ? userImages : [userImages];
+      const imageLocalFiles = [];
+      const imageUrls = [];
+      console.log("[SDK] Processing userImages:", imagesList);
+      imagesList.forEach((item) => {
+        const path = String(item).trim().replace(/^<|>$/g, "");
+        if (URL_RE.test(path)) {
+          console.log("[SDK] userImages item is URL:", path);
+          imageUrls.push(path);
+        } else {
+          console.log("[SDK] userImages item is local file:", path);
+          imageLocalFiles.push(path);
+        }
+      });
+      if (imageLocalFiles.length > 0) {
+        console.log("[SDK] Uploading", imageLocalFiles.length, "image file(s)");
+        const limit = (0, import_p_limit.default)(concurrency);
+        try {
+          const uploadedUrls = await Promise.all(
+            imageLocalFiles.map(
+              (filePath) => limit(async () => {
+                try {
+                  console.log("[SDK] Uploading image file:", filePath);
+                  const url = await this.uploadFileAndGetUrl(filePath);
+                  console.log("[SDK] Image uploaded, got URL:", url);
+                  return url;
+                } catch (error) {
+                  console.error(`[SDK] Failed to upload image file ${filePath}:`, error);
+                  throw error;
+                }
+              })
+            )
+          );
+          imageUrls.push(...uploadedUrls);
+          console.log("[SDK] All images uploaded, total URLs:", imageUrls.length);
+        } catch (error) {
+          console.error("[SDK] Error uploading image files:", error);
+          throw error;
+        }
+      }
+      if (imageUrls.length > 0) {
+        const jsonArray = JSON.stringify(imageUrls);
+        console.log("[SDK] Sending user_images as JSON:", jsonArray);
+        formData.append("user_images", jsonArray);
+      } else {
+        console.log("[SDK] No image URLs to send");
+      }
+    }
+    if (userVideos) {
+      const videosList = Array.isArray(userVideos) ? userVideos : [userVideos];
+      const videoLocalFiles = [];
+      const videoUrls = [];
+      videosList.forEach((item) => {
+        const path = String(item).trim().replace(/^<|>$/g, "");
+        if (URL_RE.test(path)) {
+          videoUrls.push(path);
+        } else {
+          videoLocalFiles.push(path);
+        }
+      });
+      if (videoLocalFiles.length > 0) {
+        const limit = (0, import_p_limit.default)(concurrency);
+        try {
+          const uploadedUrls = await Promise.all(
+            videoLocalFiles.map(
+              (filePath) => limit(async () => {
+                try {
+                  return await this.uploadFileAndGetUrl(filePath);
+                } catch (error) {
+                  console.error(`Failed to upload video file ${filePath}:`, error);
+                  throw error;
+                }
+              })
+            )
+          );
+          videoUrls.push(...uploadedUrls);
+        } catch (error) {
+          console.error("Error uploading video files:", error);
+          throw error;
+        }
+      }
+      if (videoUrls.length > 0) {
+        formData.append("user_videos", JSON.stringify(videoUrls));
       }
-      const absLogoPath = (0, import_path.resolve)(logoPath);
-      const logoFileName = (0, import_path.basename)(absLogoPath);
-      const logoMimeType = (0, import_mime_types.lookup)(absLogoPath) || "application/octet-stream";
-      formData.append("logo", (0, import_fs.createReadStream)(absLogoPath), {
-        filename: logoFileName,
-        contentType: logoMimeType
+    }
+    if (inputImages) {
+      const imagesList = Array.isArray(inputImages) ? inputImages : [inputImages];
+      const localFiles = [];
+      const imageUrls = [];
+      imagesList.forEach((item) => {
+        const path = String(item).trim().replace(/^<|>$/g, "");
+        if (URL_RE.test(path)) {
+          imageUrls.push(path);
+        } else {
+          localFiles.push(path);
+        }
       });
+      if (localFiles.length > 0) {
+        const limit = (0, import_p_limit.default)(concurrency);
+        const uploadedUrls = await Promise.all(
+          localFiles.map((filePath) => limit(() => this.uploadFileAndGetUrl(filePath)))
+        );
+        imageUrls.push(...uploadedUrls);
+      }
+      if (imageUrls.length > 0) {
+        formData.append("input_images", JSON.stringify(imageUrls));
+      }
     }
     if (uploads) {
       const list = typeof uploads === "string" ? [uploads] : [...uploads];