curl -X PUT https://api.nexusgpt.io/api/public/messages/msg-123456789/rate \
  -H "Content-Type: application/json" \
  -H "api-key: YOUR_API_KEY" \
  -d '{
    "score": 5,
    "feedback": "Very helpful and accurate response!"
  }'

const axios = require('axios');

async function rateMessage(messageId, score, feedback = null) {
  try {
    const response = await axios.put(
      `https://api.nexusgpt.io/api/public/messages/${messageId}/rate`,
      { 
        score: score,
        feedback: feedback 
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'api-key': process.env.NEXUS_API_KEY
        }
      }
    );
    
    console.log('Rating submitted successfully:', response.data);
    return response.data;
    
  } catch (error) {
    console.error('Error submitting rating:', error.response?.data);
    throw error;
  }
}

// Rate a message with score only
await rateMessage('msg-123456789', 5);

// Rate a message with score and feedback
await rateMessage('msg-123456789', 4, 'Good response but could be more detailed');

import os
import requests

def rate_message(message_id, score, feedback=None):
    """Rate an AI message with a score and optional feedback"""
    url = f"https://api.nexusgpt.io/api/public/messages/{message_id}/rate"
    
    headers = {
        "Content-Type": "application/json",
        "api-key": os.environ.get("NEXUS_API_KEY")
    }
    
    data = {
        "score": score
    }
    
    if feedback:
        data["feedback"] = feedback
    
    try:
        response = requests.put(url, json=data, headers=headers)
        response.raise_for_status()
        
        print("Rating submitted successfully:", response.json())
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f"Error submitting rating: {e}")
        if hasattr(e, 'response'):
            print(f"Response: {e.response.text}")
        raise

# Rate a message with score only
rate_message('msg-123456789', 5)

# Rate a message with score and feedback
rate_message('msg-123456789', 4, 'Good response but could be more detailed')

package main

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

type RateMessageRequest struct {
    Score    int    `json:"score"`
    Feedback string `json:"feedback,omitempty"`
}

type RateMessageResponse struct {
    ID        string `json:"id"`
    MessageID string `json:"messageId"`
    Score     int    `json:"score"`
    Feedback  string `json:"feedback,omitempty"`
    CreatedAt string `json:"createdAt"`
    UpdatedAt string `json:"updatedAt"`
}

func rateMessage(messageID string, score int, feedback string) (*RateMessageResponse, error) {
    url := fmt.Sprintf("https://api.nexusgpt.io/api/public/messages/%s/rate", messageID)
    
    requestBody := RateMessageRequest{
        Score:    score,
        Feedback: feedback,
    }
    
    jsonData, err := json.Marshal(requestBody)
    if err != nil {
        return nil, err
    }
    
    req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Content-Type", "application/json")
    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 result RateMessageResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }
    
    fmt.Printf("Rating submitted successfully: %+v\n", result)
    return &result, nil
}