Session management

interface Session {
  id: string;
  name: string;
  assistantId: string;
  status: string;
  messages: Array<{ role: string; content: string }>;
  createdAt: string;
  updatedAt: string;
}

interface ChatResponse {
  message: string;
  chat: {
    id: string;
    sessionId: string;
    input: string;
    output: Array<{ role: string; content: string }>;
    status: string;
    cost: number;
    createdAt: string;
    updatedAt: string;
  };
}

class CallHQSessionManager {
  private apiKey: string;
  private sessionId?: string;
  private sessionName: string;
  private assistantId: string;

  constructor(apiKey: string, sessionName: string, assistantId: string) {
    this.apiKey = apiKey;
    this.sessionName = sessionName;
    this.assistantId = assistantId;
  }

  async createSession(): Promise<string> {
    const response = await fetch('https://api.callhq.ai/api/sessions', {
      method: 'POST',
      headers: {
        'x-api-key': this.apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        name: this.sessionName,
        assistantId: this.assistantId
      })
    });

    if (!response.ok) {
      throw new Error(`Failed to create session: ${response.status}`);
    }

    const result = await response.json();
    this.sessionId = result.session.id;
    return this.sessionId;
  }

  async sendMessage(input: string): Promise<string> {
    if (!this.sessionId) {
      throw new Error('No active session. Create a session first.');
    }

    const response = await fetch('https://api.callhq.ai/api/chats', {
      method: 'POST',
      headers: {
        'x-api-key': this.apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        sessionId: this.sessionId,
        input
      })
    });

    if (!response.ok) {
      throw new Error(`Failed to send message: ${response.status}`);
    }

    const result: ChatResponse = await response.json();
    return result.chat.output[0].content;
  }

  async getConversationHistory(): Promise<Array<{ role: string; content: string }>> {
    if (!this.sessionId) {
      throw new Error('No active session.');
    }

    const response = await fetch(`https://api.callhq.ai/api/chats/session/${this.sessionId}`, {
      headers: {
        'x-api-key': this.apiKey
      }
    });

    if (!response.ok) {
      throw new Error(`Failed to get conversation history: ${response.status}`);
    }

    const result = await response.json();
    return result.session.messages;
  }

  getSessionId(): string | undefined {
    return this.sessionId;
  }

  isSessionActive(): boolean {
    return !!this.sessionId;
  }
}

// Usage
const sessionManager = new CallHQSessionManager(
  'your-api-key',
  'Customer Support Session',
  'your-assistant-id'
);

// Create session and start chatting
await sessionManager.createSession();
await sessionManager.sendMessage("Hello, I need help with my account");
await sessionManager.sendMessage("I forgot my password");
await sessionManager.sendMessage("What was my first question?"); // Remembers context

// Get full conversation history
const history = await sessionManager.getConversationHistory();
console.log('Conversation history:', history);

class MultiSessionManager {
  private apiKey: string;
  private sessions: Map<string, CallHQSessionManager> = new Map();

  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }

  async getOrCreateSession(sessionName: string, assistantId: string): Promise<CallHQSessionManager> {
    const key = `${sessionName}-${assistantId}`;
    
    if (!this.sessions.has(key)) {
      const sessionManager = new CallHQSessionManager(this.apiKey, sessionName, assistantId);
      await sessionManager.createSession();
      this.sessions.set(key, sessionManager);
    }

    return this.sessions.get(key)!;
  }

  async sendMessage(sessionName: string, assistantId: string, input: string): Promise<string> {
    const session = await this.getOrCreateSession(sessionName, assistantId);
    return session.sendMessage(input);
  }

  getAllSessions(): Array<{ name: string; assistantId: string; sessionId: string }> {
    return Array.from(this.sessions.entries()).map(([key, session]) => {
      const [name, assistantId] = key.split('-');
      return {
        name,
        assistantId,
        sessionId: session.getSessionId() || ''
      };
    });
  }
}

// Usage
const multiManager = new MultiSessionManager('your-api-key');

// Handle multiple customer conversations
await multiManager.sendMessage('Customer A', 'support-assistant', 'Hello, I need help');
await multiManager.sendMessage('Customer B', 'sales-assistant', 'I want to buy a product');
await multiManager.sendMessage('Customer A', 'support-assistant', 'What was my issue?'); // Remembers context

console.log('Active sessions:', multiManager.getAllSessions());