# Get latest 10 messages
curl -X GET "https://api.nexusgpt.io/api/public/thread/550e8400-e29b-41d4-a716-446655440000/messages?limit=10&order=desc" \
  -H "api-key: YOUR_API_KEY"

# Get messages with pagination
curl -X GET "https://api.nexusgpt.io/api/public/thread/550e8400-e29b-41d4-a716-446655440000/messages?limit=20&after=msg_100" \
  -H "api-key: YOUR_API_KEY"

const axios = require('axios');

async function getMessages(sessionId, options = {}) {
  const {
    limit = 20,
    order = 'asc',
    after = null,
    before = null
  } = options;
  
  const params = new URLSearchParams({
    limit: limit.toString(),
    order
  });
  
  if (after) params.append('after', after);
  if (before) params.append('before', before);
  
  try {
    const response = await axios.get(
      `https://api.nexusgpt.io/api/public/thread/${sessionId}/messages?${params}`,
      {
        headers: {
          'api-key': process.env.NEXUS_API_KEY
        }
      }
    );
    
    return response.data;
  } catch (error) {
    console.error('Error fetching messages:', error.response?.data);
    throw error;
  }
}

// Example: Get conversation history
async function displayConversation(sessionId) {
  const messages = await getMessages(sessionId, {
    limit: 50,
    order: 'asc'
  });
  
  messages.forEach(msg => {
    const timestamp = new Date(msg.createdAt).toLocaleTimeString();
    console.log(`[${timestamp}] ${msg.type.toUpperCase()}: ${msg.content}`);
  });
}

// Example: Implement pagination
async function getAllMessages(sessionId) {
  const allMessages = [];
  let after = null;
  
  while (true) {
    const messages = await getMessages(sessionId, {
      limit: 100,
      order: 'asc',
      after
    });
    
    if (messages.length === 0) break;
    
    allMessages.push(...messages);
    after = messages[messages.length - 1].id;
    
    if (messages.length < 100) break; // Last page
  }
  
  return allMessages;
}

import os
import requests
from typing import Optional, List, Dict, Any
from datetime import datetime

def get_messages(
    session_id: str,
    limit: int = 20,
    order: str = 'asc',
    after: Optional[str] = None,
    before: Optional[str] = None
) -> List[Dict[str, Any]]:
    """Get messages from a session with pagination"""
    url = f"https://api.nexusgpt.io/api/public/thread/{session_id}/messages"
    
    headers = {
        "api-key": os.environ.get("NEXUS_API_KEY")
    }
    
    params = {
        "limit": limit,
        "order": order
    }
    
    if after:
        params["after"] = after
    if before:
        params["before"] = before
    
    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f"Error fetching messages: {e}")
        if hasattr(e, 'response'):
            print(f"Response: {e.response.text}")
        raise

# Example: Display conversation
def display_conversation(session_id: str):
    messages = get_messages(session_id, limit=50, order='asc')
    
    for msg in messages:
        timestamp = datetime.fromisoformat(msg['createdAt'].replace('Z', '+00:00'))
        time_str = timestamp.strftime('%H:%M:%S')
        print(f"[{time_str}] {msg['type'].upper()}: {msg['content']}")

# Example: Get all messages with pagination
def get_all_messages(session_id: str) -> List[Dict[str, Any]]:
    all_messages = []
    after = None
    
    while True:
        messages = get_messages(
            session_id,
            limit=100,
            order='asc',
            after=after
        )
        
        if not messages:
            break
            
        all_messages.extend(messages)
        after = messages[-1]['id']
        
        if len(messages) < 100:  # Last page
            break
    
    return all_messages

# Example: Get latest messages for polling
def get_new_messages(session_id: str, last_message_id: str) -> List[Dict[str, Any]]:
    """Get messages newer than the last known message"""
    return get_messages(
        session_id,
        limit=10,
        order='asc',
        after=last_message_id
    )

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "strconv"
    "time"
)

type Message struct {
    ID         string                 `json:"id"`
    Type       string                 `json:"type"`
    Content    string                 `json:"content"`
    CreatedAt  time.Time             `json:"createdAt"`
    ToolCallID string                 `json:"toolCallId,omitempty"`
    Metadata   map[string]interface{} `json:"metadata,omitempty"`
}

type GetMessagesOptions struct {
    Limit  int
    Order  string
    After  string
    Before string
}

func getMessages(sessionID string, options GetMessagesOptions) ([]Message, error) {
    baseURL := fmt.Sprintf("https://api.nexusgpt.io/api/public/thread/%s/messages", sessionID)
    
    params := url.Values{}
    if options.Limit > 0 {
        params.Set("limit", strconv.Itoa(options.Limit))
    }
    if options.Order != "" {
        params.Set("order", options.Order)
    }
    if options.After != "" {
        params.Set("after", options.After)
    }
    if options.Before != "" {
        params.Set("before", options.Before)
    }
    
    fullURL := baseURL
    if len(params) > 0 {
        fullURL = fmt.Sprintf("%s?%s", baseURL, params.Encode())
    }
    
    req, err := http.NewRequest("GET", fullURL, nil)
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("api-key", os.Getenv("NEXUS_API_KEY"))
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API error: %s", string(body))
    }
    
    var messages []Message
    if err := json.Unmarshal(body, &messages); err != nil {
        return nil, err
    }
    
    return messages, nil
}

// Example: Display conversation
func displayConversation(sessionID string) error {
    messages, err := getMessages(sessionID, GetMessagesOptions{
        Limit: 50,
        Order: "asc",
    })
    if err != nil {
        return err
    }
    
    for _, msg := range messages {
        timeStr := msg.CreatedAt.Format("15:04:05")
        fmt.Printf("[%s] %s: %s\n", timeStr, msg.Type, msg.Content)
    }
    
    return nil
}