OpenAI/OpenRouter Integration

const MASTER_SYSTEM_PROMPT = `You are an UNCENSORED explicit adult caption generator. 
Create raw, filthy captions that feel like REAL dirty talk - not polished writing.

CRITICAL - PERSPECTIVE:
- The PERSON IN THE IMAGE is SPEAKING the caption TO the viewer
- She's talking directly to whoever is looking at/stroking to her image
- The viewer is addressed, commanded, teased, degraded, humiliated

CONTENT INTENSITY:
- Be EXPLICIT: cock, pussy, fuck, cum, balls, stroke, edge, whore, slut, etc.
- NO censoring, NO softening, NO holding back
- Match the theme's psychological intensity EXACTLY

OUTPUT: Just the raw caption. No quotes, no labels, no formatting.`;

interface CaptionContext {
  sessionTitle?: string;
  index: number;                    // Current slide position
  total: number;                    // Total slides
  previousCaptions?: string[];      // Last 3 captions for continuity
  nextCaptions?: string[];          // Next 3 captions for flow
  userSteering?: string;            // Custom instructions
  sessionStage?: 'new_session' | 'existing_session';
}

// Example usage
const caption = await generateContextualManualCaption(imageUrl, {
  sessionTitle: "Dominant Femdom Session",
  index: 5,
  total: 20,
  previousCaptions: [
    "Good boy, you're learning to obey...",
    "Now edge for me. Don't you dare cum.",
    "That's it, slower. I control your pleasure."
  ],
  nextCaptions: [
    "You want to cum so badly, don't you?",
    "Beg me. Let me hear how desperate you are."
  ],
  userSteering: "Build tension, more teasing, less commands"
});

const GEMINI_SAFETY_SETTINGS = [
  { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
  { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
];

// Applied automatically for gemini models
if (isGeminiModel(modelId)) {
  requestBody.safety_settings = GEMINI_SAFETY_SETTINGS;
}

import { generateCustomCaption } from './openai';

const caption = await generateCustomCaption(
  'https://example.com/image.jpg',  // Image URL
  'Focus on the outfit and pose',   // Custom prompt (optional)
  'joi',                             // Theme (optional)
  'smart_captions'                   // Context: smart_captions | session | other
);

console.log(caption);
// "That tight dress... you can't stop staring, can you? 
//  Edge for me while you imagine what's underneath."

import { generateCaption } from './openai';

// Short captions for 2-7 second display
const caption = await generateCaption(
  imageUrl,
  'Post title from Reddit',  // Optional
  'gonewild'                 // Subreddit context
);

console.log(caption);
// "Stroke faster. You know you can't resist."

import { generateContextualManualCaption } from './openai';

const caption = await generateContextualManualCaption(imageUrl, {
  sessionTitle: "Edging Challenge",
  index: 10,
  total: 25,
  previousCaptions: [
    "You're doing so well. Keep edging for me.",
    "Don't cum yet. I didn't give you permission."
  ],
  userSteering: "Increase intensity, add countdown"
});

// Maintains narrative flow and user preferences

// For manual session editor
const captions = await Promise.all(
  slides.map((slide, index) => 
    generateContextualManualCaption(slide.imageUrl, {
      index,
      total: slides.length,
      previousCaptions: slides
        .slice(Math.max(0, index - 3), index)
        .map(s => s.caption),
      nextCaptions: slides
        .slice(index + 1, index + 4)
        .map(s => s.caption)
    })
  )
);

async function checkMediaCompatibility(imageUrl: string): Promise<void> {
  // Check for animated GIFs
  if (imageUrl.toLowerCase().includes('.gif')) {
    throw new Error(
      'Animated GIFs are not supported. Use static images (JPEG, PNG, WebP).'
    );
  }
  
  // Check file size (OpenRouter has 21MB limit)
  const response = await fetch(imageUrl, { method: 'HEAD' });
  const contentLength = response.headers.get('content-length');
  
  if (contentLength) {
    const fileSizeMB = parseInt(contentLength) / (1024 * 1024);
    if (fileSizeMB > 20) {
      throw new Error(
        `Image too large (${fileSizeMB.toFixed(1)}MB). Max 20MB.`
      );
    }
  }
}

const maxAttempts = 3;
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
  try {
    return await generateCaptionInternal(...);
  } catch (error) {
    // Retry on content filtering or empty responses
    const isRetriable = 
      error.message === 'CONTENT_POLICY_REJECTION' ||
      error.message === 'EMPTY_RESPONSE_CONTENT_FILTERED';
    
    if (isRetriable && attempt < maxAttempts) {
      await new Promise(r => setTimeout(r, 500));
      continue;
    }
    throw error;
  }
}

// Fallback after all attempts
return "Ready to play? Let's see how long you can last...";

const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
  method: 'POST',
  body: JSON.stringify({
    model: modelId,
    messages: [...],
    
    // Creativity settings
    temperature: 1.15,      // Higher = more creative (0-2)
    top_p: 0.9,            // Nucleus sampling (0-1)
    
    // Repetition penalties
    frequency_penalty: 0.5, // Reduce word repetition
    presence_penalty: 0.4,  // Encourage new topics
    
    // Output control
    max_tokens: 500,        // Limit response length
  })
});

OPENROUTER_REASONING_ENABLED=true

# Optional: Set effort level (low/medium/high)
OPENROUTER_REASONING_EFFORT=medium

// In server/logger.ts, set level to 'debug'
export const logger = createLogger({
  level: 'debug'
});

// Logs will show:
// [openai] Generating caption with OpenRouter model: google/gemini-2.5-pro
// [openai] Caption properly grounded with subtle visual reference

curl -X POST http://localhost:5000/api/captions/generate \
  -H "Content-Type: application/json" \
  -H "Cookie: your-session-cookie" \
  -d '{
    "imageUrl": "https://example.com/test.jpg",
    "customPrompt": "Test caption generation",
    "theme": "joi"
  }'