@zodic/shared 0.0.375 → 0.0.377

package/app/services/ArchetypeService.ts

@@ -791,7 +791,7 @@ export class ArchetypeService {
         );
         const contentResponse = await this.context
           .api()
-          .callTogether.single(contentMessages, {});
+          .callTogether.single(contentMessages, { max_tokens: 10000 });
         if (!contentResponse) {
           await this.log(
             'error',

package/app/workflow/ArchetypeWorkflow.ts

@@ -1,8 +1,8 @@
+import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
-import { AppContext } from '../base';
-import { Gender, Languages } from '../../types';
 import { ArchetypeService, LeonardoService, schema } from '../..';
-import { and, eq } from 'drizzle-orm';
+import { Gender, Languages } from '../../types';
+import { AppContext } from '../base';
 
 @injectable()
 export class ArchetypeWorkflow {
@@ -38,8 +38,17 @@ export class ArchetypeWorkflow {
 
     try {
       // Step 1: Generate archetype names for both genders
-      await this.log('debug', 'Generating archetype names', { combinationString, override, userId });
-      await this.archetypeService.generateArchetypeNames(combinationString, override);
+      if (override) {
+        await this.log('debug', 'Generating archetype names', {
+          combinationString,
+          override,
+          userId,
+        });
+        await this.archetypeService.generateArchetypeNames(
+          combinationString,
+          override
+        );
+      }
 
       // Step 2: Generate descriptions and virtues for both genders
       await this.log('debug', 'Generating descriptions and virtues', {
@@ -49,12 +58,13 @@ export class ArchetypeWorkflow {
         override,
         userId,
       });
-      const descriptions = await this.archetypeService.generateDescriptionsAndVirtues(
-        combinationString,
-        gender, // Service processes both genders internally
-        language,
-        override
-      );
+      const descriptions =
+        await this.archetypeService.generateDescriptionsAndVirtues(
+          combinationString,
+          gender, // Service processes both genders internally
+          language,
+          override
+        );
 
       // Step 3: Generate content for both genders
       await this.log('debug', 'Generating content', {
@@ -102,50 +112,70 @@ export class ArchetypeWorkflow {
       );
 
       if (archetypes.length !== 3) {
-        await this.log('error', `Expected 3 archetypes for ${gender}, found ${archetypes.length}`, {
-          combinationString,
-          gender,
-          language,
-          userId,
-        });
+        await this.log(
+          'error',
+          `Expected 3 archetypes for ${gender}, found ${archetypes.length}`,
+          {
+            combinationString,
+            gender,
+            language,
+            userId,
+          }
+        );
         throw new Error(
           `Expected 3 archetypes for combination ${combinationString}, gender ${gender}, language ${language}, but found ${archetypes.length}`
         );
       }
 
       // Step 6: Process image generation only for the requested gender
-      await this.log('info', `Processing image generation for gender ${gender}`, {
-        archetypeIds: archetypes.map((a) => a.id),
-        archetypeIndexes: archetypes.map((a) => a.archetypeIndex),
-        userId,
-      });
+      await this.log(
+        'info',
+        `Processing image generation for gender ${gender}`,
+        {
+          archetypeIds: archetypes.map((a) => a.id),
+          archetypeIndexes: archetypes.map((a) => a.archetypeIndex),
+          userId,
+        }
+      );
       for (const archetype of archetypes) {
         if (!archetype.leonardoPrompt) {
-          await this.log('warn', `No Leonardo prompt for archetype ${archetype.id}`, {
-            archetypeIndex: archetype.archetypeIndex,
-            gender,
-            language,
-            userId,
-          });
+          await this.log(
+            'warn',
+            `No Leonardo prompt for archetype ${archetype.id}`,
+            {
+              archetypeIndex: archetype.archetypeIndex,
+              gender,
+              language,
+              userId,
+            }
+          );
           continue;
         }
 
         if (override || !archetype.images || archetype.images === '[]') {
-          await this.log('debug', `Queueing image generation for archetype ${archetype.id}`, {
-            archetypeIndex: archetype.archetypeIndex,
-            gender,
-            language,
-            userId,
-          });
+          await this.log(
+            'debug',
+            `Queueing image generation for archetype ${archetype.id}`,
+            {
+              archetypeIndex: archetype.archetypeIndex,
+              gender,
+              language,
+              userId,
+            }
+          );
           await this.leonardoService.processArchetypePopulation(archetype.id);
         } else {
-          await this.log('debug', `Skipping image generation for archetype ${archetype.id}`, {
-            reason: 'Images already exist and override is false',
-            archetypeIndex: archetype.archetypeIndex,
-            gender,
-            language,
-            userId,
-          });
+          await this.log(
+            'debug',
+            `Skipping image generation for archetype ${archetype.id}`,
+            {
+              reason: 'Images already exist and override is false',
+              archetypeIndex: archetype.archetypeIndex,
+              gender,
+              language,
+              userId,
+            }
+          );
         }
       }
 
@@ -163,13 +193,17 @@ export class ArchetypeWorkflow {
           const images = archetype.images ? JSON.parse(archetype.images) : [];
           imageCount = Array.isArray(images) ? images.length : 0;
         } catch (error) {
-          await this.log('warn', `Failed to parse images for archetype ${archetype.id}`, {
-            archetypeIndex: archetype.archetypeIndex,
-            gender,
-            language,
-            userId,
-            error: error instanceof Error ? error.message : String(error),
-          });
+          await this.log(
+            'warn',
+            `Failed to parse images for archetype ${archetype.id}`,
+            {
+              archetypeIndex: archetype.archetypeIndex,
+              gender,
+              language,
+              userId,
+              error: error instanceof Error ? error.message : String(error),
+            }
+          );
           continue;
         }
 
@@ -185,24 +219,35 @@ export class ArchetypeWorkflow {
                 eq(schema.archetypesData.id, archetype.id),
                 eq(schema.archetypesData.gender, gender),
                 eq(schema.archetypesData.language, language),
-                eq(schema.archetypesData.archetypeIndex, archetype.archetypeIndex)
+                eq(
+                  schema.archetypesData.archetypeIndex,
+                  archetype.archetypeIndex
+                )
               )
             );
-          await this.log('info', `Updated status to 'completed' for archetype ${archetype.id}`, {
-            archetypeIndex: archetype.archetypeIndex,
-            gender,
-            language,
-            imageCount,
-            userId,
-          });
+          await this.log(
+            'info',
+            `Updated status to 'completed' for archetype ${archetype.id}`,
+            {
+              archetypeIndex: archetype.archetypeIndex,
+              gender,
+              language,
+              imageCount,
+              userId,
+            }
+          );
         } else {
-          await this.log('debug', `Skipping status update for archetype ${archetype.id}`, {
-            reason: `Fewer than 3 images (found ${imageCount})`,
-            archetypeIndex: archetype.archetypeIndex,
-            gender,
-            language,
-            userId,
-          });
+          await this.log(
+            'debug',
+            `Skipping status update for archetype ${archetype.id}`,
+            {
+              reason: `Fewer than 3 images (found ${imageCount})`,
+              archetypeIndex: archetype.archetypeIndex,
+              gender,
+              language,
+              userId,
+            }
+          );
         }
       }
 
@@ -223,4 +268,4 @@ export class ArchetypeWorkflow {
       throw error;
     }
   }
-}
+}

package/package.json

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

package/types/scopes/generic.ts

@@ -347,7 +347,12 @@ export const ConceptPhases: Record<string, ConceptPhase> = {
   IMAGES: 'images',
 };
 
-export type DeepSeekOptions = { model?: string; options?: Record<string, any>, temperature?: number};
+export type DeepSeekOptions = {
+  model?: string;
+  options?: Record<string, any>;
+  temperature?: number;
+  max_tokens?: number;
+};
 export type DeepSeekBatchInputItem = {
   messages: ChatMessages;
   options?: DeepSeekOptions;
@@ -644,9 +649,9 @@ export interface Usage {
 }
 
 export enum Status {
-  Completed = "Completed",
-  Failed = "Failed",
-  Pending = "Pending",
-  Processing = "Processing",
-  Staged = "Staged",
-}
+  Completed = 'Completed',
+  Failed = 'Failed',
+  Pending = 'Pending',
+  Processing = 'Processing',
+  Staged = 'Staged',
+}