feat: Added multiturn messaging and tracking of scenario/description changes.

src/app/api/proxy/route.ts

@@ -1,9 +1,32 @@
 import { NextResponse } from "next/server";
 import type { NextRequest } from "next/server";
 
+interface CardVersion {
+  version: number;
+  timestamp: number;
+  changes: {
+    description?: { old: string; new: string };
+    scenario?: { old: string; new: string };
+  };
+  changeType: 'initial' | 'update';
+  messageCount: number;
+  addedText?: {
+    description?: string;
+    scenario?: string;
+  };
+  removedText?: {
+    description?: string;
+    scenario?: string;
+  };
+}
+
 interface StoredCard extends CardData {
   timestamp: number;
   id: string;
+  versions: CardVersion[];
+  currentVersion: number;
+  messageCount: number;
+  conversationId: string;
 }
 
 let extractedCards: StoredCard[] = [];
@@ -26,6 +49,7 @@ interface Message {
 
 interface CardData {
   name: string;
+  trackingName: string;
   first_mes: string;
   description: string;
   personality: string;
@@ -61,12 +85,23 @@ function extractCardData(messages: Message[]): CardData {
   
   const nameContent = messages[3].content;
   const lastColonIndex = nameContent.lastIndexOf(': ');
-  const nameFromUser = lastColonIndex !== -1 ? nameContent.substring(lastColonIndex + 2) : '';
+  const nameFromUser = lastColonIndex !== -1 ? nameContent.substring(lastColonIndex + 2).trim() : '';
   
   let content = messages[0].content.replace(/{user}/g, '{{user}}');
   const inferredName = extractPersonaName(content);
   content = removePersonaTags(content);
-  const name = nameFromUser === '.' && inferredName ? inferredName : nameFromUser;
+  
+  // Use inferred name for tracking, but keep user input for display
+  const trackingName = inferredName || nameFromUser || 'Unknown Character';
+  let displayName = nameFromUser;
+  if (nameFromUser === '.' || nameFromUser === '') {
+    displayName = inferredName || 'Unknown Character';
+  }
+  
+  // Clean up tracking name
+  const cleanTrackingName = trackingName.replace(/[^a-zA-Z0-9\s]/g, '').trim();
+  
+  console.log(`Name extraction: user="${nameFromUser}", inferred="${inferredName}", tracking="${cleanTrackingName}", display="${displayName}"`);
   
   if (!content.includes('<.>') || !content.includes('<UserPersona>.</UserPersona>')) {
     throw new Error('Required substrings not found');
@@ -93,7 +128,8 @@ function extractCardData(messages: Message[]): CardData {
   const description = content.trim();
   
   return {
-    name,
+    name: displayName,
+    trackingName: cleanTrackingName,
     first_mes,
     description,
     personality: '',
@@ -102,6 +138,82 @@ function extractCardData(messages: Message[]): CardData {
   };
 }
 
+function generateConversationId(messages: Message[]): string {
+  // Create a simple hash from the character name in the persona tag to identify conversations
+  const content = messages[0]?.content || '';
+  const personaMatch = content.match(/<([^<>]+?)\s*'s\s+Persona>/i);
+  if (personaMatch) {
+    return personaMatch[1].trim().toLowerCase().replace(/[^a-zA-Z0-9]/g, '');
+  }
+  // Fallback to content-based ID
+  return content.substring(0, 50).replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+}
+
+function detectChanges(newCard: CardData, existingCard: StoredCard): { description?: { old: string; new: string }; scenario?: { old: string; new: string } } | null {
+  const changes: { description?: { old: string; new: string }; scenario?: { old: string; new: string } } = {};
+  let hasChanges = false;
+
+  if (newCard.description.trim() !== existingCard.description.trim()) {
+    changes.description = { old: existingCard.description, new: newCard.description };
+    hasChanges = true;
+  }
+
+  if (newCard.scenario.trim() !== existingCard.scenario.trim()) {
+    changes.scenario = { old: existingCard.scenario, new: newCard.scenario };
+    hasChanges = true;
+  }
+
+  return hasChanges ? changes : null;
+}
+
+function findExistingCard(trackingName: string): StoredCard | null {
+  // Find by tracking name (inferred character name) to group same characters
+  return extractedCards.find(card => card.trackingName === trackingName) || null;
+}
+
+function updateCardWithVersion(existingCard: StoredCard, newCard: CardData, changes: { description?: { old: string; new: string }; scenario?: { old: string; new: string } }): void {
+  const addedText: { description?: string; scenario?: string } = {};
+  const removedText: { description?: string; scenario?: string } = {};
+  
+  // Extract only the different text
+  if (changes.description) {
+    const added = extractAddedText(changes.description.old, changes.description.new);
+    const removed = extractRemovedText(changes.description.old, changes.description.new);
+    if (added) addedText.description = added;
+    if (removed) removedText.description = removed;
+  }
+  
+  if (changes.scenario) {
+    const added = extractAddedText(changes.scenario.old, changes.scenario.new);
+    const removed = extractRemovedText(changes.scenario.old, changes.scenario.new);
+    if (added) addedText.scenario = added;
+    if (removed) removedText.scenario = removed;
+  }
+
+  const newVersion: CardVersion = {
+    version: existingCard.currentVersion + 1,
+    timestamp: Date.now(),
+    changes,
+    changeType: 'update',
+    messageCount: existingCard.messageCount + 1,
+    addedText: Object.keys(addedText).length > 0 ? addedText : undefined,
+    removedText: Object.keys(removedText).length > 0 ? removedText : undefined
+  };
+
+  existingCard.versions.push(newVersion);
+  existingCard.currentVersion = newVersion.version;
+  existingCard.timestamp = Date.now();
+  existingCard.messageCount += 1;
+  
+  // Update the main card data
+  if (changes.description) {
+    existingCard.description = changes.description.new;
+  }
+  if (changes.scenario) {
+    existingCard.scenario = changes.scenario.new;
+  }
+}
+
 export async function POST(request: NextRequest) {
   if (request.method === "OPTIONS") {
     return new NextResponse(null, {
@@ -117,7 +229,14 @@ export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
 
+    // Check if this is a streaming request (JanitorAI expects SSE)
+    const acceptHeader = request.headers.get('accept');
+    const isStreamingRequest = acceptHeader?.includes('text/event-stream') || body.stream === true;
+
     if (!body.messages || body.messages.length < 2) {
+      if (isStreamingRequest) {
+        return createSSEErrorResponse("Missing messages or insufficient message count");
+      }
       return NextResponse.json(
         { error: "Missing messages or insufficient message count" },
         {
@@ -130,56 +249,243 @@ export async function POST(request: NextRequest) {
     }
 
     const cardData = extractCardData(body.messages);
-    extractedCards.push({
-      ...cardData,
-      timestamp: Date.now(),
-      id: generateId(),
-    });
+    const conversationId = generateConversationId(body.messages);
+    const existingCard = findExistingCard(cardData.trackingName);
+    
+    console.log(`Conversation ID: ${conversationId}`);
+
+    let responseMessage = "Got it.";
+    let changesSummary = "";
+
+    console.log(`Processing card: "${cardData.name}" (tracking: "${cardData.trackingName}"), ConversationID: ${conversationId}`);
+    console.log(`Existing cards: ${extractedCards.map(c => `"${c.name}" (tracking: "${c.trackingName}", v${c.currentVersion})`).join(', ')}`);
+    console.log(`Found existing card: ${existingCard ? `YES - v${existingCard.currentVersion}` : 'NO'}`);
+
+    if (existingCard) {
+      const changes = detectChanges(cardData, existingCard);
+      console.log(`Changes detected:`, changes ? 'YES' : 'NO');
+      if (changes) {
+        console.log(`Updating from v${existingCard.currentVersion} to v${existingCard.currentVersion + 1}`);
+        updateCardWithVersion(existingCard, cardData, changes);
+        
+        // Keep the original display name (don't update it)
+        // existingCard.name stays the same
+        
+        // Create a summary of changes for the response
+        const changeTypes = [];
+        if (changes.description) changeTypes.push("description");
+        if (changes.scenario) changeTypes.push("scenario");
+        
+        changesSummary = ` Changes detected in ${changeTypes.join(" and ")}.`;
+        responseMessage = `Character updated (v${existingCard.currentVersion}).${changesSummary}`;
+      } else {
+        existingCard.messageCount += 1;
+        // Keep the original display name (don't update it)
+        // existingCard.name stays the same
+        responseMessage = `Character data unchanged (v${existingCard.currentVersion}, message ${existingCard.messageCount}).`;
+      }
+    } else {
+      // Create new card with initial version
+      const newCard: StoredCard = {
+        ...cardData,
+        timestamp: Date.now(),
+        id: generateId(),
+        conversationId,
+        messageCount: 1,
+        versions: [{
+          version: 1,
+          timestamp: Date.now(),
+          changes: {
+            description: { old: "", new: cardData.description },
+            scenario: { old: "", new: cardData.scenario }
+          },
+          changeType: 'initial',
+          messageCount: 1
+        }],
+        currentVersion: 1
+      };
+      extractedCards.push(newCard);
+      responseMessage = `New character "${cardData.trackingName}" created (v1).`;
+    }
 
     cleanupExpiredCards();
 
+    // Return SSE response if requested, otherwise JSON
+    if (isStreamingRequest) {
+      return createSSEResponse(responseMessage);
+    }
+
+    // Return proper OpenAI-compatible response
     return NextResponse.json(
       { 
+        id: `chatcmpl-${generateId()}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: "sucker-v2",
         choices: [{ 
+          index: 0,
           message: { 
-            content: "Got it." 
-          } 
-        }] 
+            role: "assistant",
+            content: responseMessage
+          },
+          finish_reason: "stop"
+        }],
+        usage: {
+          prompt_tokens: 0,
+          completion_tokens: responseMessage.split(' ').length,
+          total_tokens: responseMessage.split(' ').length
+        }
       },
       {
         headers: {
           "Access-Control-Allow-Origin": "*",
+          "Content-Type": "application/json",
         },
       }
     );
   } catch (error) {
     console.error("Error processing request:", error);
     
+    const errorMessage = "You dingus, read the directions on sucker before trying again.";
+    
+    // Check if this was a streaming request
+    const acceptHeader = request.headers.get('accept');
+    const isStreamingRequest = acceptHeader?.includes('text/event-stream');
+    
+    if (isStreamingRequest) {
+      return createSSEErrorResponse(errorMessage);
+    }
+    
     return NextResponse.json(
       { 
+        id: `chatcmpl-${generateId()}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: "sucker-v2",
         choices: [{ 
+          index: 0,
           message: { 
-            content: "You dingus, read the directions on sucker before trying again." 
-          } 
-        }] 
+            role: "assistant",
+            content: errorMessage
+          },
+          finish_reason: "stop"
+        }],
+        usage: {
+          prompt_tokens: 0,
+          completion_tokens: errorMessage.split(' ').length,
+          total_tokens: errorMessage.split(' ').length
+        }
       },
       {
-        status: 400,
+        status: 200, // Change to 200 so Janitor AI accepts it
         headers: {
           "Access-Control-Allow-Origin": "*",
+          "Content-Type": "application/json",
         },
       }
     );
   }
 }
 
-export async function GET() {
+function getInitialCardVersion(card: StoredCard): CardData {
+  // Get the initial version (v1) of the card
+  const initialVersion = card.versions.find(v => v.version === 1);
+  if (initialVersion && initialVersion.changes.description && initialVersion.changes.scenario) {
+    return {
+      name: card.name,
+      trackingName: card.trackingName,
+      first_mes: card.first_mes,
+      description: initialVersion.changes.description.new,
+      personality: card.personality,
+      mes_example: card.mes_example,
+      scenario: initialVersion.changes.scenario.new,
+    };
+  }
+  // Fallback to current version if initial not found
+  return {
+    name: card.name,
+    trackingName: card.trackingName,
+    first_mes: card.first_mes,
+    description: card.description,
+    personality: card.personality,
+    mes_example: card.mes_example,
+    scenario: card.scenario,
+  };
+}
+
+export async function GET(request: NextRequest) {
   cleanupExpiredCards();
 
+  const url = new URL(request.url);
+  const isChangesRequest = url.searchParams.get('changes') === 'true';
+  const cardId = url.searchParams.get('cardId');
+
+  if (isChangesRequest && cardId) {
+    const card = extractedCards.find(c => c.id === cardId);
+    
+    if (!card || !card.versions) {
+      return NextResponse.json(
+        { error: "Card not found or no version history available" },
+        { 
+          status: 404,
+          headers: {
+            "Access-Control-Allow-Origin": "*",
+          },
+        }
+      );
+    }
+
+    const changesReport = {
+      cardName: card.name,
+      cardId: card.id,
+      totalVersions: card.versions.length,
+      currentVersion: card.currentVersion,
+      versions: card.versions.map((version, index) => {
+        const result: any = {
+          version: version.version,
+          timestamp: new Date(version.timestamp).toISOString(),
+          changeType: version.changeType,
+          changes: version.changes
+        };
+
+        // Add extracted text information
+        if (version.addedText) {
+          result.addedText = version.addedText;
+        }
+        if (version.removedText) {
+          result.removedText = version.removedText;
+        }
+
+        return result;
+      }),
+      summary: generateChangesSummary(card.versions)
+    };
+
+    // Sanitize filename for download
+    const sanitizedName = card.name.replace(/[^a-zA-Z0-9\-_]/g, '_');
+
+    return NextResponse.json(changesReport, {
+      headers: {
+        "Access-Control-Allow-Origin": "*",
+        "Content-Disposition": `attachment; filename="${sanitizedName}_changes.json"`,
+      },
+    });
+  }
+
   return NextResponse.json(
     {
       status: "online",
-      cards: extractedCards.map(({ timestamp, ...card }) => card),
+      cards: extractedCards.map((card) => {
+        const { timestamp, versions, ...cardData } = card;
+        const initialVersion = getInitialCardVersion(card);
+        return {
+          ...cardData,
+          hasVersions: versions && versions.length > 1,
+          versionCount: versions ? versions.length : 0,
+          messageCount: card.messageCount || 1,
+          initialVersion: initialVersion
+        };
+      }),
     },
     {
       headers: {
@@ -189,6 +495,231 @@ export async function GET() {
   );
 }
 
+interface DiffResult {
+  type: 'added' | 'removed' | 'unchanged';
+  text: string;
+}
+
+function extractAddedText(oldText: string, newText: string): string {
+  // Split by double newlines to get paragraphs, then by single newlines to get lines
+  const oldParagraphs = oldText.split(/\n\s*\n/);
+  const newParagraphs = newText.split(/\n\s*\n/);
+  
+  const addedBlocks: string[] = [];
+  
+  // Find paragraphs that exist in new but not in old
+  for (const newPara of newParagraphs) {
+    const newParaTrimmed = newPara.trim();
+    if (!newParaTrimmed) continue;
+    
+    // Check if this paragraph (or a very similar one) exists in old text
+    let found = false;
+    for (const oldPara of oldParagraphs) {
+      const oldParaTrimmed = oldPara.trim();
+      if (!oldParaTrimmed) continue;
+      
+      // Check for exact match or high similarity (80% of words match)
+      if (oldParaTrimmed === newParaTrimmed || calculateSimilarity(oldParaTrimmed, newParaTrimmed) > 0.8) {
+        found = true;
+        break;
+      }
+    }
+    
+    if (!found) {
+      addedBlocks.push(newParaTrimmed);
+    }
+  }
+  
+  return addedBlocks.join('\n\n');
+}
+
+function extractRemovedText(oldText: string, newText: string): string {
+  // Split by double newlines to get paragraphs
+  const oldParagraphs = oldText.split(/\n\s*\n/);
+  const newParagraphs = newText.split(/\n\s*\n/);
+  
+  const removedBlocks: string[] = [];
+  
+  // Find paragraphs that exist in old but not in new
+  for (const oldPara of oldParagraphs) {
+    const oldParaTrimmed = oldPara.trim();
+    if (!oldParaTrimmed) continue;
+    
+    // Check if this paragraph (or a very similar one) exists in new text
+    let found = false;
+    for (const newPara of newParagraphs) {
+      const newParaTrimmed = newPara.trim();
+      if (!newParaTrimmed) continue;
+      
+      // Check for exact match or high similarity (80% of words match)
+      if (oldParaTrimmed === newParaTrimmed || calculateSimilarity(oldParaTrimmed, newParaTrimmed) > 0.8) {
+        found = true;
+        break;
+      }
+    }
+    
+    if (!found) {
+      removedBlocks.push(oldParaTrimmed);
+    }
+  }
+  
+  return removedBlocks.join('\n\n');
+}
+
+function calculateSimilarity(text1: string, text2: string): number {
+  const words1 = text1.toLowerCase().split(/\s+/);
+  const words2 = text2.toLowerCase().split(/\s+/);
+  
+  const set1 = new Set(words1);
+  const set2 = new Set(words2);
+  
+  const intersection = new Set([...set1].filter(x => set2.has(x)));
+  const union = new Set([...set1, ...set2]);
+  
+  return intersection.size / union.size;
+}
+
+function generateChangesSummary(versions: CardVersion[]) {
+  const summary = {
+    descriptionChanges: 0,
+    scenarioChanges: 0,
+    totalMessages: 0,
+    firstChange: null as string | null,
+    lastChange: null as string | null,
+  };
+
+  versions.forEach(version => {
+    if (version.changes.description !== undefined) {
+      summary.descriptionChanges++;
+    }
+    if (version.changes.scenario !== undefined) {
+      summary.scenarioChanges++;
+    }
+    summary.totalMessages = Math.max(summary.totalMessages, version.messageCount || 0);
+  });
+
+  if (versions.length > 0) {
+    summary.firstChange = new Date(versions[0].timestamp).toISOString();
+    summary.lastChange = new Date(versions[versions.length - 1].timestamp).toISOString();
+  }
+
+  return summary;
+}
+
+// SSE Helper Functions
+function createSSEResponse(content: string): Response {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send the message in OpenAI streaming format
+      const id = `chatcmpl-${generateId()}`;
+      const timestamp = Math.floor(Date.now() / 1000);
+      
+      // Send initial chunk with message
+      const chunk = {
+        id,
+        object: "chat.completion.chunk",
+        created: timestamp,
+        model: "sucker-v2",
+        choices: [{
+          index: 0,
+          delta: {
+            role: "assistant",
+            content: content
+          },
+          finish_reason: null
+        }]
+      };
+      
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+      
+      // Send final chunk to indicate completion
+      const finalChunk = {
+        id,
+        object: "chat.completion.chunk", 
+        created: timestamp,
+        model: "sucker-v2",
+        choices: [{
+          index: 0,
+          delta: {},
+          finish_reason: "stop"
+        }]
+      };
+      
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify(finalChunk)}\n\n`));
+      controller.enqueue(encoder.encode(`data: [DONE]\n\n`));
+      controller.close();
+    }
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, OPTIONS, GET',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    },
+  });
+}
+
+function createSSEErrorResponse(errorMessage: string): Response {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      const id = `chatcmpl-${generateId()}`;
+      const timestamp = Math.floor(Date.now() / 1000);
+      
+      // Send error as a normal message chunk
+      const chunk = {
+        id,
+        object: "chat.completion.chunk",
+        created: timestamp,
+        model: "sucker-v2",
+        choices: [{
+          index: 0,
+          delta: {
+            role: "assistant",
+            content: errorMessage
+          },
+          finish_reason: null
+        }]
+      };
+      
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+      
+      // Send final chunk
+      const finalChunk = {
+        id,
+        object: "chat.completion.chunk",
+        created: timestamp,
+        model: "sucker-v2",
+        choices: [{
+          index: 0,
+          delta: {},
+          finish_reason: "stop"
+        }]
+      };
+      
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify(finalChunk)}\n\n`));
+      controller.enqueue(encoder.encode(`data: [DONE]\n\n`));
+      controller.close();
+    }
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, OPTIONS, GET',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    },
+  });
+}
+
 export async function OPTIONS() {
   return new NextResponse(null, {
     status: 204,