curl -X GET https://api.nexusgpt.io/api/public/thread/550e8400-e29b-41d4-a716-446655440000 \
  -H "api-key: YOUR_API_KEY"

const axios = require('axios');

async function getSession(sessionId) {
  try {
    const response = await axios.get(
      `https://api.nexusgpt.io/api/public/thread/${sessionId}`,
      {
        headers: {
          'api-key': process.env.NEXUS_API_KEY
        }
      }
    );
    
    const session = response.data;
    console.log(`Session Status: ${session.status}`);
    console.log(`Topic: ${session.topic || 'No topic yet'}`);
    console.log(`Messages: ${session.messageCount}`);
    
    return session;
  } catch (error) {
    if (error.response?.status === 404) {
      console.error('Session not found');
    } else {
      console.error('Error fetching session:', error.response?.data);
    }
    throw error;
  }
}

// Get session information
const session = await getSession('550e8400-e29b-41d4-a716-446655440000');

import os
import requests
from datetime import datetime

def get_session(session_id):
    """Get information about a specific session"""
    url = f"https://api.nexusgpt.io/api/public/thread/{session_id}"
    
    headers = {
        "api-key": os.environ.get("NEXUS_API_KEY")
    }
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        
        session = response.json()
        print(f"Session Status: {session['status']}")
        print(f"Topic: {session.get('topic', 'No topic yet')}")
        print(f"Messages: {session.get('messageCount', 0)}")
        
        # Calculate session age
        created = datetime.fromisoformat(session['createdAt'].replace('Z', '+00:00'))
        age = datetime.now(created.tzinfo) - created
        print(f"Session Age: {age}")
        
        return session
        
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 404:
            print("Session not found")
        else:
            print(f"Error fetching session: {e}")
        raise

# Get session information
session = get_session('550e8400-e29b-41d4-a716-446655440000')

package main

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

type Session struct {
    ID            string    `json:"id"`
    Topic         string    `json:"topic"`
    Status        string    `json:"status"`
    CreatedAt     time.Time `json:"createdAt"`
    LastMessageAt time.Time `json:"lastMessageAt"`
    MessageCount  int       `json:"messageCount"`
    Metadata      struct {
        AgentID       string `json:"agentId"`
        IntegrationID string `json:"integrationId"`
    } `json:"metadata"`
}

func getSession(sessionID string) (*Session, error) {
    url := fmt.Sprintf("https://api.nexusgpt.io/api/public/thread/%s", sessionID)
    
    req, err := http.NewRequest("GET", url, 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.StatusNotFound {
        return nil, fmt.Errorf("session not found")
    }
    
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API error: %s", string(body))
    }
    
    var session Session
    if err := json.Unmarshal(body, &session); err != nil {
        return nil, err
    }
    
    fmt.Printf("Session Status: %s\n", session.Status)
    fmt.Printf("Topic: %s\n", session.Topic)
    fmt.Printf("Messages: %d\n", session.MessageCount)
    
    // Calculate session age
    age := time.Since(session.CreatedAt)
    fmt.Printf("Session Age: %s\n", age)
    
    return &session, nil
}