@zodic/shared 0.0.80 → 0.0.82

package/app/services/ArchetypeService.ts

@@ -18,7 +18,7 @@ export class ArchetypeService {
       .buildLLMMessages()
       .generateCosmicMirrorArchetypeBasicInfo({ sun, ascendant, moon });
 
-    const response = await this.context.api().callDeepSeek.single(messages, {});
+    const response = await this.context.api().callChatGPT.single(messages, {});
 
     if (!response) {
       throw new Error(
@@ -152,12 +152,7 @@ export class ArchetypeService {
     const kvStore = this.context.kvCosmicMirrorArchetypesStore();
 
     const kvKeys = [1, 2, 3].map((index) =>
-      buildCosmicMirrorArchetypeKVKey(
-        'en-us',
-        combinationString,
-        'male',
-        index
-      )
+      buildCosmicMirrorArchetypeKVKey('en-us', combinationString, 'male', index)
     );
 
     const archetypeEntries = await Promise.all(
@@ -179,7 +174,7 @@ export class ArchetypeService {
         }))
       );
 
-    const response = await this.context.api().callDeepSeek.single(messages, {});
+    const response = await this.context.api().callChatGPT.single(messages, {});
     if (!response) {
       throw new Error(
         `Failed to generate Leonardo prompts for: ${combinationString}`

package/app/services/LeonardoService.ts

@@ -155,7 +155,7 @@ export class LeonardoService {
     const messages = this.context
       .buildLLMMessages()
       .generateCosmicMirrorArchetypesLeonardoPrompts(archetypes);
-    const response = await this.context.api().callDeepSeek.single(messages, {});
+    const response = await this.context.api().callChatGPT.single(messages, {});
 
     if (!response) {
       throw new Error('Leonardo prompts not generated');
@@ -194,4 +194,195 @@ export class LeonardoService {
       throw error;
     }
   }
+
+  async uploadImage(
+    file: File
+  ): Promise<{ uploadedImageId: string; uploadedImageUrl: string }> {
+    const fileName = file.name;
+    const fileExtension = fileName.split('.').pop()?.toLowerCase();
+    const mimeType = `image/${fileExtension}`;
+
+    if (!fileExtension) {
+      throw new Error('Invalid file extension');
+    }
+
+    console.log('Starting uploadImage with details:', {
+      fileName,
+      fileExtension,
+      mimeType,
+    });
+
+    try {
+      console.log('Requesting presigned URL...');
+      const presignedUrlData = await this.context
+        .api()
+        .callLeonardo.generatePresignedUrl({
+          extension: fileExtension,
+        });
+
+      if (
+        !presignedUrlData.url ||
+        !presignedUrlData.fields ||
+        !presignedUrlData.id
+      ) {
+        throw new Error('Invalid presigned URL response from API');
+      }
+
+      console.log('Uploading file...');
+      await this.uploadToPresignedUrl(
+        presignedUrlData.url,
+        presignedUrlData.fields,
+        file
+      );
+
+      const uploadedImageId = presignedUrlData.id;
+      const uploadedImageUrl = `https://cdn.leonardo.ai/users/b117a933-e5c9-45b2-96aa-4b619c2d74ba/initImages/${uploadedImageId}.${fileExtension}`;
+
+      console.log('File uploaded successfully:', {
+        uploadedImageId,
+        uploadedImageUrl,
+      });
+
+      return { uploadedImageId, uploadedImageUrl };
+    } catch (error: any) {
+      console.error('Error during image upload:', error.message);
+      throw new Error('Failed to upload image');
+    }
+  }
+
+  async uploadImageByUrl(
+    imageUrl: string
+  ): Promise<{ uploadedImageId: string; uploadedImageUrl: string }> {
+    console.log('Starting uploadImageByUrl with imageUrl:', imageUrl);
+
+    try {
+      // Fetch the image from the provided URL
+      console.log('Fetching image from URL...');
+      const response = await fetch(imageUrl);
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch image from URL: ${response.statusText}`
+        );
+      }
+
+      const blob = await response.blob();
+      const fileExtension = imageUrl.split('.').pop()?.toLowerCase() || 'jpg';
+      const mimeType = blob.type || `image/${fileExtension}`;
+
+      if (!fileExtension || !mimeType.startsWith('image/')) {
+        throw new Error('Invalid image URL or file type');
+      }
+
+      console.log('Image fetched successfully:', {
+        fileExtension,
+        mimeType,
+      });
+
+      // Request a presigned URL for uploading
+      console.log('Requesting presigned URL...');
+      const presignedUrlData = await this.context
+        .api()
+        .callLeonardo.generatePresignedUrl({
+          extension: fileExtension,
+        });
+
+      if (
+        !presignedUrlData.url ||
+        !presignedUrlData.fields ||
+        !presignedUrlData.id
+      ) {
+        throw new Error('Invalid presigned URL response from API');
+      }
+
+      console.log('Presigned URL obtained:', presignedUrlData);
+
+      // Prepare the file to upload
+      const file = new File([blob], `upload.${fileExtension}`, {
+        type: mimeType,
+      });
+
+      console.log('Uploading file to presigned URL...');
+      await this.uploadToPresignedUrl(
+        presignedUrlData.url,
+        presignedUrlData.fields,
+        file as any
+      );
+
+      const uploadedImageId = presignedUrlData.id;
+      const uploadedImageUrl = `https://cdn.leonardo.ai/users/b117a933-e5c9-45b2-96aa-4b619c2d74ba/initImages/${uploadedImageId}.${fileExtension}`;
+
+      console.log('Image uploaded successfully:', {
+        uploadedImageId,
+        uploadedImageUrl,
+      });
+
+      return { uploadedImageId, uploadedImageUrl };
+    } catch (error: any) {
+      console.error('Error during uploadImageByUrl:', error.message);
+      throw new Error('Failed to upload image by URL');
+    }
+  }
+
+  private async uploadToPresignedUrl(
+    presignedUrl: string,
+    fields: string,
+    file: File
+  ): Promise<void> {
+    const parsedFields = JSON.parse(fields);
+    const formData = new FormData();
+
+    Object.entries(parsedFields).forEach(([key, value]) => {
+      formData.append(key, value as string);
+    });
+    formData.append('file', file);
+
+    console.log('Uploading with FormData:', Array.from(formData.entries()));
+
+    const response = await fetch(presignedUrl, {
+      method: 'POST',
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const errorDetails = await response.text();
+      console.error('Upload failed:', errorDetails);
+      throw new Error(`Image upload failed: ${response.status}`);
+    }
+
+    console.log('Upload to presigned URL successful');
+  }
+
+  /**
+ * Personalizes a Leonardo prompt based on user-specific traits.
+ * @param params - Details for prompt personalization
+ * @returns {Promise<string>} - The personalized prompt
+ */
+async personalizeCosmicMirrorLeonardoPrompt(params: {
+  leonardoPrompt: string;
+  traits: string;
+}): Promise<string> {
+  const { leonardoPrompt, traits } = params;
+
+  const messages = this.context
+    .buildLLMMessages()
+    .personalizeCosmicMirrorLeonardoPrompt({ leonardoPrompt, traits });
+
+  try {
+    const personalizedPrompt = await this.context
+      .api()
+      .callChatGPT.single(messages, {});
+
+    if (!personalizedPrompt) {
+      throw new Error('Failed to generate personalized prompt');
+    }
+
+    console.log('Personalized Leonardo Prompt:', personalizedPrompt);
+
+    return personalizedPrompt.trim();
+  } catch (error) {
+    console.error('Error personalizing Leonardo prompt:', error);
+    throw error;
+  }
+}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {