Migrating to Completions v2

-- Chat sessions table
CREATE TABLE chats (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id VARCHAR(255) NOT NULL,
    title VARCHAR(500),
    tradition VARCHAR(50), -- 'evangelical', 'catholic', 'mainline'
    metadata JSONB,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW(),
    
    INDEX idx_user_id (user_id),
    INDEX idx_updated_at (updated_at)
);

-- Messages table
CREATE TABLE messages (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
    role VARCHAR(50) NOT NULL, -- 'user', 'assistant', 'system'
    content TEXT NOT NULL,
    model VARCHAR(100), -- Store which model generated this response
    tokens_used INTEGER, -- Track token usage per message
    metadata JSONB,
    created_at TIMESTAMP DEFAULT NOW(),
    
    INDEX idx_chat_id_created (chat_id, created_at)
);

-- Optional: Store sources/citations
CREATE TABLE message_sources (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
    source_title VARCHAR(500),
    source_url TEXT,
    publisher VARCHAR(255),
    relevance_score DECIMAL(3,2),
    created_at TIMESTAMP DEFAULT NOW()
);

import { v4 as uuidv4 } from 'uuid';

interface Message {
  id: string;
  chat_id: string;
  role: 'user' | 'assistant' | 'system';
  content: string;
  model?: string;
  tokens_used?: number;
  created_at: Date;
}

interface Chat {
  id: string;
  user_id: string;
  title?: string;
  tradition?: 'evangelical' | 'catholic' | 'mainline';
  created_at: Date;
  updated_at: Date;
}

class ConversationManager {
  private db: any; // Your database client
  
  constructor(db: any) {
    this.db = db;
  }
  
  /**
   * Create a new chat session
   */
  async createChat(
    userId: string, 
    tradition?: Chat['tradition'],
    title?: string
  ): Promise<Chat> {
    const chat: Chat = {
      id: uuidv4(),
      user_id: userId,
      title: title || 'New Conversation',
      tradition,
      created_at: new Date(),
      updated_at: new Date()
    };
    
    await this.db.chats.insert(chat);
    return chat;
  }
  
  /**
   * Add a message to the conversation
   */
  async addMessage(
    chatId: string,
    role: Message['role'],
    content: string,
    metadata?: {
      model?: string;
      tokens_used?: number;
    }
  ): Promise<Message> {
    const message: Message = {
      id: uuidv4(),
      chat_id: chatId,
      role,
      content,
      model: metadata?.model,
      tokens_used: metadata?.tokens_used,
      created_at: new Date()
    };
    
    await this.db.messages.insert(message);
    
    // Update chat's updated_at timestamp
    await this.db.chats.update(
      { id: chatId },
      { updated_at: new Date() }
    );
    
    return message;
  }
  
  /**
   * Get conversation history formatted for Completions v2
   */
  async getConversationHistory(
    chatId: string,
    options?: {
      maxMessages?: number;
      maxTokens?: number;
    }
  ): Promise<Array<{ role: string; content: string }>> {
    const messages = await this.db.messages
      .find({ chat_id: chatId })
      .sort({ created_at: 'asc' })
      .toArray();
    
    // Apply any filtering/truncation based on options
    let filtered = messages;
    
    if (options?.maxMessages) {
      filtered = messages.slice(-options.maxMessages);
    }
    
    if (options?.maxTokens) {
      filtered = this.truncateByTokens(filtered, options.maxTokens);
    }
    
    // Format for Completions v2
    return filtered.map(msg => ({
      role: msg.role,
      content: msg.content
    }));
  }
  
  /**
   * Truncate messages to fit within token limit
   */
  private truncateByTokens(
    messages: Message[],
    maxTokens: number
  ): Message[] {
    let totalTokens = 0;
    const result: Message[] = [];
    
    // Keep system message if present
    if (messages[0]?.role === 'system') {
      result.push(messages[0]);
      totalTokens += this.estimateTokens(messages[0].content);
      messages = messages.slice(1);
    }
    
    // Add messages from most recent, working backwards
    for (let i = messages.length - 1; i >= 0; i--) {
      const tokens = this.estimateTokens(messages[i].content);
      if (totalTokens + tokens > maxTokens) break;
      
      result.unshift(messages[i]);
      totalTokens += tokens;
    }
    
    return result;
  }
  
  /**
   * Rough token estimation (4 chars ≈ 1 token)
   */
  private estimateTokens(text: string): number {
    return Math.ceil(text.length / 4);
  }
  
  /**
   * Get all chats for a user
   */
  async getUserChats(userId: string): Promise<Chat[]> {
    return await this.db.chats
      .find({ user_id: userId })
      .sort({ updated_at: 'desc' })
      .toArray();
  }
  
  /**
   * Delete a conversation
   */
  async deleteChat(chatId: string): Promise<void> {
    await this.db.messages.deleteMany({ chat_id: chatId });
    await this.db.chats.delete({ id: chatId });
  }
}

interface CompletionsV2Config {
  apiKey: string;
  baseUrl?: string;
}

interface CompletionOptions {
  tradition?: 'evangelical' | 'catholic' | 'mainline';
  autoRouting?: boolean;
  model?: string;
  modelFamily?: 'openai' | 'anthropic' | 'google' | 'open source';
  stream?: boolean;
  temperature?: number;
  maxTokens?: number;
}

class GlooCompletionsV2Client {
  private apiKey: string;
  private baseUrl: string;
  
  constructor(config: CompletionsV2Config) {
    this.apiKey = config.apiKey;
    this.baseUrl = config.baseUrl || 'https://platform.ai.gloo.com';
  }
  
  async createCompletion(
    messages: Array<{ role: string; content: string }>,
    options: CompletionOptions = {}
  ) {
    const {
      tradition,
      autoRouting = true,
      model,
      modelFamily,
      stream = false,
      temperature,
      maxTokens
    } = options;
    
    // Build request body based on routing strategy
    const body: any = {
      messages,
      stream
    };
    
    // Routing configuration
    if (autoRouting) {
      body.auto_routing = true;
    } else if (model) {
      body.model = model;
      body.auto_routing = false;
    } else if (modelFamily) {
      body.model_family = modelFamily;
      body.auto_routing = false;
    }
    
    // Optional parameters
    if (tradition) body.tradition = tradition;
    if (temperature !== undefined) body.temperature = temperature;
    if (maxTokens) body.max_tokens = maxTokens;
    
    const response = await fetch(
      `${this.baseUrl}/ai/v2/chat/completions`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(body)
      }
    );
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Completions API error: ${error.message || response.statusText}`);
    }
    
    const data = await response.json();
    return data;
  }
}

// Complete chat service combining conversation management and Completions v2
class ChatService {
  private conversationManager: ConversationManager;
  private completionsClient: GlooCompletionsV2Client;
  
  constructor(
    conversationManager: ConversationManager,
    completionsClient: GlooCompletionsV2Client
  ) {
    this.conversationManager = conversationManager;
    this.completionsClient = completionsClient;
  }
  
  /**
   * Create a new conversation
   */
  async createConversation(
    userId: string,
    tradition?: 'evangelical' | 'catholic' | 'mainline',
    title?: string
  ) {
    return await this.conversationManager.createChat(userId, tradition, title);
  }
  
  /**
   * Send a message and get AI response
   */
  async sendMessage(
    chatId: string,
    userMessage: string,
    options?: CompletionOptions
  ): Promise<{
    response: string;
    model: string;
    tokensUsed: number;
  }> {
    // 1. Store user message
    await this.conversationManager.addMessage(chatId, 'user', userMessage);
    
    // 2. Get conversation history
    const history = await this.conversationManager.getConversationHistory(
      chatId,
      {
        maxMessages: 50, // Keep last 50 messages
        maxTokens: 8000  // Adjust based on your model's context window
      }
    );
    
    // 3. Get chat details for tradition
    const chat = await this.conversationManager.db.chats.findOne({ id: chatId });
    const completionOptions = {
      ...options,
      tradition: options?.tradition || chat?.tradition
    };
    
    // 4. Call Completions v2
    const completion = await this.completionsClient.createCompletion(
      history,
      completionOptions
    );
    
    const assistantMessage = completion.choices[0].message.content;
    const tokensUsed = completion.usage.total_tokens;
    const model = completion.model;
    
    // 5. Store assistant response
    await this.conversationManager.addMessage(
      chatId,
      'assistant',
      assistantMessage,
      {
        model,
        tokens_used: tokensUsed
      }
    );
    
    return {
      response: assistantMessage,
      model,
      tokensUsed
    };
  }
  
  /**
   * Get conversation history
   */
  async getHistory(chatId: string) {
    return await this.conversationManager.getConversationHistory(chatId);
  }
  
  /**
   * List user's conversations
   */
  async listConversations(userId: string) {
    return await this.conversationManager.getUserChats(userId);
  }
  
  /**
   * Delete a conversation
   */
  async deleteConversation(chatId: string) {
    await this.conversationManager.deleteChat(chatId);
  }
}

// Usage Example
const conversationManager = new ConversationManager(db);
const completionsClient = new GlooCompletionsV2Client({
  apiKey: process.env.GLOO_API_KEY!
});
const chatService = new ChatService(conversationManager, completionsClient);

// Create a new conversation
const chat = await chatService.createConversation(
  'user-123',
  'evangelical',
  'Finding Purpose'
);

// Send messages
const response1 = await chatService.sendMessage(
  chat.id,
  'How can I find meaning and purpose when facing life\'s greatest challenges?',
  { autoRouting: true }
);

console.log('AI Response:', response1.response);
console.log('Model Used:', response1.model);
console.log('Tokens:', response1.tokensUsed);

// Continue the conversation
const response2 = await chatService.sendMessage(
  chat.id,
  'Can you give me practical steps I can take today?'
);

console.log('Follow-up Response:', response2.response);

async function migrateExistingChats(userId: string) {
  console.log(`Starting migration for user: ${userId}`);
  
  // 1. Get all chats from old Chat API
  const chatsResponse = await fetch(
    `https://platform.ai.gloo.com/ai/v1/chat?user_id=${userId}`,
    {
      headers: { 'Authorization': `Bearer ${oldApiToken}` }
    }
  );
  const oldChats = await chatsResponse.json();
  
  console.log(`Found ${oldChats.length} chats to migrate`);
  
  for (const oldChat of oldChats) {
    try {
      // 2. Get messages for this chat
      const messagesResponse = await fetch(
        `https://platform.ai.gloo.com/ai/v1/chat/${oldChat.id}/messages`,
        {
          headers: { 'Authorization': `Bearer ${oldApiToken}` }
        }
      );
      const oldMessages = await messagesResponse.json();
      
      // 3. Create new chat in your system
      const newChat = await conversationManager.createChat(
        oldChat.user_id,
        undefined, // Set tradition if you have this info
        oldChat.title || 'Migrated Conversation'
      );
      
      // 4. Migrate all messages
      for (const oldMessage of oldMessages.messages) {
        await conversationManager.addMessage(
          newChat.id,
          oldMessage.role,
          oldMessage.content || oldMessage.message
        );
      }
      
      console.log(`✓ Migrated chat ${oldChat.id} → ${newChat.id}`);
      
    } catch (error) {
      console.error(`✗ Failed to migrate chat ${oldChat.id}:`, error);
    }
  }
  
  console.log('Migration complete!');
}

// Run migration
await migrateExistingChats('user-123');