AI Integration

OPENAI_API_KEY="sk-proj-xxxxxxxxxxxxxxxxxxxx"

// From openai.service.ts:76-133
async generatePosts(content: string) {
  const posts = await Promise.all([
    // Single posts
    openai.chat.completions.create({
      messages: [
        {
          role: 'assistant',
          content: 'Generate a Twitter post from the content without emojis'
        },
        { role: 'user', content: content }
      ],
      n: 5,
      temperature: 1,
      model: 'gpt-4.1',
    }),
    // Thread posts
    openai.chat.completions.create({
      messages: [
        {
          role: 'assistant',
          content: 'Generate a thread for social media without emojis'
        },
        { role: 'user', content: content }
      ],
      n: 5,
      temperature: 1,
      model: 'gpt-4.1',
    }),
  ]);
  
  return shuffle(posts.flatMap(p => p.choices));
}

// From openai.service.ts:21-32
async generateImage(prompt: string, isUrl: boolean, isVertical = false) {
  const generate = await openai.images.generate({
    prompt,
    response_format: isUrl ? 'url' : 'b64_json',
    model: 'dall-e-3',
    ...(isVertical ? { size: '1024x1792' } : { size: '1024x1024' }),
  });
  
  return isUrl ? generate.data[0].url : generate.data[0].b64_json;
}

// From openai.service.ts:34-53
async generatePromptForPicture(prompt: string) {
  return await openai.chat.completions.parse({
    model: 'gpt-4.1',
    messages: [
      {
        role: 'system',
        content: `You are an assistant that takes a description and style 
                  and generates a prompt for image generation. Make it very 
                  long and descriptive. For realistic styles, describe camera 
                  settings, lighting, composition, etc.`
      },
      { role: 'user', content: `prompt: ${prompt}` }
    ],
    response_format: zodResponseFormat(PicturePrompt, 'picturePrompt'),
  });
}

// From openai.service.ts:155-227
async separatePosts(content: string, len: number) {
  const posts = await openai.chat.completions.parse({
    model: 'gpt-4.1',
    messages: [
      {
        role: 'system',
        content: `Break this post into a thread. Each post must be 
                  minimum ${len - 10} and maximum ${len} characters, 
                  keeping exact wording and line breaks. Split based 
                  on context.`
      },
      { role: 'user', content: content }
    ],
    response_format: zodResponseFormat(SeparatePostsPrompt, 'separatePosts'),
  });
  
  return { posts: posts.choices[0].message.parsed?.posts || [] };
}

// From openai.service.ts:229-270
async generateSlidesFromText(text: string) {
  const parse = await openai.chat.completions.parse({
    model: 'gpt-4.1',
    messages: [
      {
        role: 'system',
        content: `Break text into 3-5 slides maximum. Each slide needs:
                  - Image prompt (with dark gradient, no text in image)
                  - Voice text for narration`
      },
      { role: 'user', content: text }
    ],
    response_format: zodResponseFormat(
      z.object({
        slides: z.array(
          z.object({
            imagePrompt: z.string(),
            voiceText: z.string(),
          })
        )
      }),
      'slides'
    ),
  });
  
  return parse.choices[0].message.parsed?.slides || [];
}

// From openai.service.ts:55-74
async generateVoiceFromText(prompt: string) {
  return await openai.chat.completions.parse({
    model: 'gpt-4.1',
    messages: [
      {
        role: 'system',
        content: `Convert this social media post to natural human speech.
                  Remove hyphens, add pauses with "...", make it sound 
                  like a real person talking.`
      },
      { role: 'user', content: `prompt: ${prompt}` }
    ],
    response_format: zodResponseFormat(VoicePrompt, 'voice'),
  });
}

// From openai.service.ts:134-153
async extractWebsiteText(content: string) {
  const websiteContent = await openai.chat.completions.create({
    messages: [
      {
        role: 'assistant',
        content: 'Extract only the article content from this website text'
      },
      { role: 'user', content }
    ],
    model: 'gpt-4.1',
  });
  
  const articleContent = websiteContent.choices[0].message.content;
  
  // Generate posts from extracted content
  return this.generatePosts(articleContent);
}

model: 'gpt-4.1'

import { zodResponseFormat } from 'openai/helpers/zod';
import { z } from 'zod';

const PicturePrompt = z.object({
  prompt: z.string(),
});

const response = await openai.chat.completions.parse({
  model: 'gpt-4.1',
  messages: [...],
  response_format: zodResponseFormat(PicturePrompt, 'picturePrompt'),
});

// From openai.service.ts:230-268
for (let i = 0; i < 3; i++) {
  try {
    const parse = await openai.chat.completions.parse({
      model: 'gpt-4.1',
      messages: [...],
      response_format: zodResponseFormat(schema, 'name'),
    });
    
    return parse;
  } catch (err) {
    console.log(err);
    // Retry up to 3 times
  }
}

return []; // Fallback to empty result

{
  role: 'system',
  content: 'Your custom instructions here'
}

model: 'gpt-3.5-turbo'  // Cheaper but lower quality
model: 'gpt-4.1'        // Current default
model: 'gpt-4o'         // Latest model

temperature: 0.7  // More consistent
temperature: 1.0  // Current default - balanced
temperature: 1.5  // More creative

# Remove or comment out the OPENAI_API_KEY
# OPENAI_API_KEY=""