@zodic/shared 0.0.42 → 0.0.44

package/api/index.ts

@@ -1,5 +1,9 @@
 import {
   BackendBindings,
+  BatchInputItem,
+  BatchProcessingResult,
+  BatchResponse,
+  ChatGPTFileUploadResponse,
   ChatMessages,
   NatalChartInterpretation,
 } from '../types';
@@ -18,39 +22,120 @@ import {
 import { makeAstrologyApiCall } from './astrology';
 
 export const Api = (env: BackendBindings) => ({
-  callChatGPT: async (
-    messages: ChatMessages,
-    { model = 'gpt-4', options = {} }: ChatGPTOptions
-  ): Promise<string> => {
-    const endpoint = 'https://api.openai.com/v1/chat/completions';
-    const headers = {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${env.OPENAI_API_KEY}`,
-    };
+  callChatGPT: {
+    single: async (
+      messages: ChatMessages,
+      { model = 'gpt-4', options = {} }: ChatGPTOptions
+    ): Promise<string> => {
+      const endpoint = 'https://api.openai.com/v1/chat/completions';
+      const headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${env.OPENAI_API_KEY}`,
+      };
 
-    const body = JSON.stringify({
-      model,
-      messages,
-      ...options,
-    });
+      const body = JSON.stringify({
+        model,
+        messages,
+        ...options,
+      });
 
-    try {
-      const response = await fetch(endpoint, { method: 'POST', headers, body });
+      try {
+        const response = await fetch(endpoint, {
+          method: 'POST',
+          headers,
+          body,
+        });
 
-      if (!response.ok) {
-        const error = await response.json();
-        console.error('Error from OpenAI API:', error);
-        throw new Error(`OpenAI API Error: ${response.status}`);
+        if (!response.ok) {
+          const error = await response.json();
+          console.error('Error from OpenAI API:', error);
+          throw new Error(`OpenAI API Error: ${response.status}`);
+        }
+
+        const data = (await response.json()) as any;
+        return data.choices[0].message.content.trim() as string;
+      } catch (err: any) {
+        console.error('Error calling ChatGPT API:', err.message);
+        throw err;
+      }
+    },
+    batch: async (
+      env: BackendBindings,
+      batchItems: BatchInputItem[]
+    ): Promise<BatchProcessingResult[]> => {
+      console.log('Preparing to send ChatGPT batch request.');
+
+      const uploadEndpoint = 'https://api.openai.com/v1/files';
+      const batchEndpoint = 'https://api.openai.com/v1/batches';
+      const apiKey = env.OPENAI_API_KEY;
+
+      if (!apiKey) {
+        throw new Error('OPENAI_API_KEY is not defined in the environment.');
       }
 
-      const data = (await response.json()) as any;
-      return data.choices[0].message.content.trim() as string;
-    } catch (err: any) {
-      console.error('Error calling ChatGPT API:', err.message);
-      throw err;
-    }
-  },
+      try {
+        // Step 1: Upload the input file
+        const inputFile = JSON.stringify(batchItems);
+        const uploadResponse = await fetch(uploadEndpoint, {
+          method: 'POST',
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+          },
+          body: new Blob([inputFile], { type: 'application/json' }),
+        });
+
+        if (!uploadResponse.ok) {
+          const uploadError = await uploadResponse.json();
+          console.error('Failed to upload input file:', uploadError);
+          throw new Error(
+            `File upload failed with status ${uploadResponse.status}`
+          );
+        }
 
+        const uploadData =
+          (await uploadResponse.json()) as ChatGPTFileUploadResponse;
+        const fileId = uploadData.id;
+        console.log(`File uploaded successfully. File ID: ${fileId}`);
+
+        // Step 2: Submit the batch request
+        const batchPayload = {
+          file: fileId,
+          purpose: 'fine-tune', // Define the correct purpose based on OpenAI's API
+        };
+
+        const batchResponse = await fetch(batchEndpoint, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+          },
+          body: JSON.stringify(batchPayload),
+        });
+
+        if (!batchResponse.ok) {
+          const batchError = await batchResponse.json();
+          console.error('Failed to create batch:', batchError);
+          throw new Error(
+            `Batch creation failed with status ${batchResponse.status}`
+          );
+        }
+
+        const batchData = (await batchResponse.json()) as BatchResponse;
+        console.log(`Batch created successfully. Batch ID: ${batchData.id}`);
+
+        // Step 3: Poll for batch results (not shown here; depends on the implementation)
+
+        return batchItems.map((item) => ({
+          id: item.id,
+          status: 'completed', // Placeholder; actual status would depend on polling results
+          content: undefined, // Placeholder for actual response
+        }));
+      } catch (error) {
+        console.error('Error in callChatGPTBatch:', error);
+        throw error;
+      }
+    },
+  },
   callLeonardo: {
     generateImage: async ({
       prompt,

package/app/workflow/ConceptWorkflow.ts

@@ -1,6 +1,6 @@
 import { inject } from 'inversify';
-import { ConceptService } from '../services/ConceptService';
 import { ConceptPhase } from '../../types/scopes/legacy';
+import { ConceptService } from '../services/ConceptService';
 
 export class ConceptWorkflow {
   constructor(@inject(ConceptService) private conceptService: ConceptService) {}
@@ -16,7 +16,7 @@ export class ConceptWorkflow {
 
     try {
       switch (phase) {
-        case 'name-description-poem':
+        case 'basic-info':
           await this.conceptService.generateBasicInfo(
             conceptSlug,
             combinationString

package/package.json

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

package/types/scopes/generic.ts

@@ -139,3 +139,45 @@ export type ConceptQueueMessage = {
   combinationString: string;
   phase: ConceptPhase;
 };
+
+export type BatchInputItem = {
+  id: string;
+  messages: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>;
+};
+
+export type BatchResponseItem = {
+  id: string;
+  status: 'completed' | 'failed';
+  result?: {
+    choices: Array<{
+      message: {
+        role: string;
+        content: string;
+      };
+    }>;
+  };
+  error?: any;
+};
+
+export type BatchProcessingResult = {
+  id: string;
+  status: 'completed' | 'failed';
+  content?: string;
+  error?: any;
+};
+
+export type ChatGPTBatchResult = {
+  id: string;
+  status: 'completed' | 'failed';
+  content?: string;
+  error?: any;
+};
+
+export type ChatGPTFileUploadResponse = {
+  id: string; // Unique identifier for the uploaded file
+  object: string; // Type of the object, usually "file"
+  bytes: number; // File size in bytes
+  created_at: number; // Timestamp when the file was created
+  filename: string; // Name of the uploaded file
+  purpose: string; // Purpose of the file, e.g., "fine-tune"
+};

package/types/scopes/legacy.ts

@@ -2,7 +2,7 @@ import { BackendBindings } from './cloudflare';
 import { Gender } from './generic';
 
 export type ConceptPhase =
-  | 'name-description-poem'
+  | 'basic-info'
   | 'leonardo-prompt'
   | 'content'
   | 'images';