Register Agent Run

curl -X POST https://api.fabraix.com/v1/register-agent-run \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "a1b2c3d4-e5f6-7890-1234-567890abcdef",
    "timestamp": "2024-01-15T14:30:45.123Z",
    "system_prompt": "You are a helpful customer service assistant. You should be polite and professional."
  }'

import requests
import uuid
from datetime import datetime

# Configuration
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.fabraix.com/v1"

# Create request
agent_id = uuid.uuid4()
request_data = {
    "agent_id": str(agent_id),
    "timestamp": datetime.now().isoformat(),
    "system_prompt": "You are a helpful customer service assistant."
}

# Make API call
response = requests.post(
    f"{BASE_URL}/register-agent-run",
    headers={
        "x-api-key": API_KEY,
        "Content-Type": "application/json"
    },
    json=request_data
)

# Extract trace_id
result = response.json()
trace_id = result["trace_id"]
print(f"Session started with trace_id: {trace_id}")

const axios = require('axios');
const { v4: uuidv4 } = require('uuid');

// Configuration
const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.fabraix.com/v1';

// Create request
const agentId = uuidv4();
const requestData = {
  agent_id: agentId,
  timestamp: new Date().toISOString(),
  system_prompt: 'You are a helpful customer service assistant.'
};

// Make API call
async function registerAgentRun() {
  try {
    const response = await axios.post(
      `${BASE_URL}/register-agent-run`,
      requestData,
      {
        headers: {
          'x-api-key': API_KEY,
          'Content-Type': 'application/json'
        }
      }
    );
    
    const traceId = response.data.trace_id;
    console.log(`Session started with trace_id: ${traceId}`);
    return traceId;
  } catch (error) {
    console.error('Error registering agent run:', error);
    throw error;
  }
}

registerAgentRun();

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
    "github.com/google/uuid"
)

type RegisterRequest struct {
    AgentID      string    `json:"agent_id"`
    Timestamp    time.Time `json:"timestamp"`
    SystemPrompt string    `json:"system_prompt"`
}

type RegisterResponse struct {
    TraceID   string    `json:"trace_id"`
    Timestamp time.Time `json:"timestamp"`
}

func registerAgentRun(apiKey string) (string, error) {
    url := "https://api.fabraix.com/v1/register-agent-run"
    
    // Create request
    agentID := uuid.New().String()
    reqData := RegisterRequest{
        AgentID:      agentID,
        Timestamp:    time.Now(),
        SystemPrompt: "You are a helpful customer service assistant.",
    }
    
    jsonData, err := json.Marshal(reqData)
    if err != nil {
        return "", err
    }
    
    // Make HTTP request
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return "", err
    }
    
    req.Header.Set("x-api-key", apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    
    // Parse response
    var result RegisterResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return "", err
    }
    
    fmt.Printf("Session started with trace_id: %s\n", result.TraceID)
    return result.TraceID, nil
}

{
  "error": {
    "message": "Invalid agent_id format",
    "type": "validation_error",
    "code": "INVALID_AGENT_ID"
  }
}

{
  "error": {
    "message": "Invalid API key provided",
    "type": "authentication_error",
    "code": "INVALID_API_KEY"
  }
}

{
  "error": {
    "message": "Rate limit exceeded",
    "type": "rate_limit_error",
    "retry_after": 30
  }
}