@zodic/shared 0.0.315 → 0.0.316

package/app/api/index.ts

@@ -46,20 +46,20 @@ export const Api = (env: BackendBindings) => ({
           messages,
           ...options,
         });
-  
+
         if (!response.choices[0].message.content) {
           throw new Error('Content is null');
         }
-  
+
         // ✅ Extract API usage data
         const { usage } = response;
         if (usage) {
           console.log(`📊 API Usage: Tokens - ${usage.total_tokens}`);
-  
+
           if (env.KV_API_USAGE) {
             // ✅ Check how many usage logs exist
             const { keys } = await env.KV_API_USAGE.list({ prefix: 'usage:' });
-  
+
             if (keys.length < 10) {
               // ✅ Store new entry ONLY if there are less than 10
               const timestamp = new Date().toISOString();
@@ -70,22 +70,27 @@ export const Api = (env: BackendBindings) => ({
                 completion_tokens: usage.completion_tokens,
                 timestamp,
               };
-  
-              await env.KV_API_USAGE.put(`usage:${timestamp}`, JSON.stringify(logEntry), {
-                expirationTtl: 60 * 60 * 24 * 7, // ✅ Store for 7 days
-              });
-  
+
+              await env.KV_API_USAGE.put(
+                `usage:${timestamp}`,
+                JSON.stringify(logEntry),
+                {
+                  expirationTtl: 60 * 60 * 24 * 7, // ✅ Store for 7 days
+                }
+              );
+
               console.log(`✅ Logged API usage (Entry ${keys.length + 1}/10)`);
             } else {
-              console.log(`⏳ API usage logging skipped: 10 records already exist.`);
+              console.log(
+                `⏳ API usage logging skipped: 10 records already exist.`
+              );
             }
           }
         } else {
           console.warn('⚠️ API Usage Data Missing');
         }
-  
+
         return response.choices[0].message.content.trim();
-        
       } catch (err: any) {
         console.error('❌ Error calling Together API:', err.message);
         throw err;
@@ -263,9 +268,9 @@ export const Api = (env: BackendBindings) => ({
       prompt,
       width,
       height,
-      controlNets = [], // Optional
-      initImageId = null, // Optional
-      initStrength = 0.2, // Default strength for Image-to-Image
+      controlNets = [],
+      initImageId = null,
+      initStrength = 0.2,
       quantity = 3,
       negPrompt = null,
     }: LeonardoGenerateImageParams & {
@@ -297,7 +302,6 @@ export const Api = (env: BackendBindings) => ({
         num_images: quantity,
       };
 
-      // ✅ Dynamically add `controlNets` based on available settings
       if (controlNets.length > 0) {
         // @ts-expect-error
         body['controlnets'] = controlNets.map((net) => {
@@ -342,6 +346,100 @@ export const Api = (env: BackendBindings) => ({
         throw err;
       }
     },
+
+    generatePresignedUrl: async (): Promise<{
+      id: string;
+      fields: string;
+      key: string;
+      url: string;
+    }> => {
+      const endpoint = 'https://cloud.leonardo.ai/api/rest/v1/init-image';
+      const headers = {
+        Authorization: `Bearer ${env.LEONARDO_API_KEY}`,
+        'Content-Type': 'application/json',
+      };
+
+      try {
+        const response = await fetch(endpoint, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({}),
+        });
+
+        if (!response.ok) {
+          const error = await response.json();
+          console.error(
+            '❌ Error generating presigned URL from Leonardo API:',
+            error
+          );
+          throw new Error(`Leonardo API Error: ${response.status}`);
+        }
+
+        const data = await response.json() as any;
+        const result = data.uploadInitImage;
+
+        if (
+          !result ||
+          !result.id ||
+          !result.url ||
+          !result.fields ||
+          !result.key
+        ) {
+          console.error('❌ Invalid response from Leonardo API:', data);
+          throw new Error('Invalid response structure from Leonardo API');
+        }
+
+        return {
+          id: result.id,
+          fields: result.fields,
+          key: result.key,
+          url: result.url,
+        };
+      } catch (err: any) {
+        console.error('❌ Error generating presigned URL:', err.message);
+        throw err;
+      }
+    },
+
+    uploadImageToPresignedUrl: async (
+      file: File,
+      presignedResponse: { fields: string; url: string }
+    ): Promise<void> => {
+      const rawFields = presignedResponse.fields;
+      const fields = JSON.parse(rawFields);
+      const url = presignedResponse.url;
+
+      const formData = new FormData();
+
+      // Append all fields from the presigned response
+      Object.entries(fields).forEach(([key, value]) => {
+        formData.append(key, value as string);
+      });
+
+      // Append the file as the last field, as required by Leonardo.ai
+      formData.append('file', file);
+
+      try {
+        const response = await fetch(url, {
+          method: 'POST',
+          body: formData,
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          console.error(
+            '❌ Error uploading image to presigned URL:',
+            errorText
+          );
+          throw new Error(`Failed to upload image: ${response.status}`);
+        }
+
+        console.log('✅ Successfully uploaded image to Leonardo.ai');
+      } catch (err: any) {
+        console.error('❌ Error uploading image:', err.message);
+        throw err;
+      }
+    },
   },
   callImageDescriber: async (imageUrl: string): Promise<string> => {
     const mimeType = 'image/png';