API Documentation

GET /api/v1/users/ HTTP/1.1
Host: api.fauri.ai
X-Client-ID: your_client_id
X-Secret-Key: your_secret_key
Content-Type: application/json

// Connect to the Fauri AI agent via WebSocket
const WS_URL = "wss://api.fauri.ai/ws/agent/";
const CLIENT_ID = "your_client_id";
const SECRET_KEY = "your_secret_key";
const USER_ID = "0x1234...abcd";

const ws = new WebSocket(
  `${WS_URL}?client_id=${CLIENT_ID}&secret_key=${SECRET_KEY}&user_id=${USER_ID}`
);

ws.onopen = () => {
  console.log("Connected to Fauri agent");
  ws.send(JSON.stringify({
    message: "Show me running shoes under $150"
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log("Agent response:", data.message);

  // Handle product results
  if (data.products) {
    data.products.forEach(p => {
      console.log(`  - ${p.name}: $${p.price}`);
    });
  }
};

ws.onerror = (error) => {
  console.error("WebSocket error:", error);
};

ws.onclose = () => {
  console.log("Disconnected from Fauri agent");
};

// Fetch chat history via REST API
const API_URL = "https://api.fauri.ai";
const CLIENT_ID = "your_client_id";
const SECRET_KEY = "your_secret_key";

async function getChatHistory(userId) {
  const res = await fetch(
    `${API_URL}/api/v1/chat/history/?user_id=${userId}`,
    {
      headers: {
        "X-Client-ID": CLIENT_ID,
        "X-Secret-Key": SECRET_KEY,
      },
    }
  );
  return await res.json();
}

// List all users
async function listUsers() {
  const res = await fetch(`${API_URL}/api/v1/users/`, {
    headers: {
      "X-Client-ID": CLIENT_ID,
      "X-Secret-Key": SECRET_KEY,
    },
  });
  return await res.json();
}

// Verify webhook signature (Node.js / Express)
const crypto = require("crypto");

function verifyWebhookSignature(body, timestamp, signature, secret) {
  // Signature is HMAC-SHA256 of "{timestamp}.{body}"
  const expected = "sha256=" + crypto
    .createHmac("sha256", secret)
    .update(`${timestamp}.${body}`)
    .digest("hex");
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

app.post("/webhooks/kays", express.raw({ type: "application/json" }), (req, res) => {
  const signature = req.headers["x-webhook-signature"];
  const timestamp = req.headers["x-webhook-timestamp"];
  const body = req.body.toString();

  if (!verifyWebhookSignature(body, timestamp, signature, process.env.KAYS_WEBHOOK_SECRET)) {
    return res.status(401).json({ error: "Invalid signature" });
  }

  const payload = JSON.parse(body);
  const { type, user_id, amount, order_id } = payload;

  if (type === "balance_check") {
    const canAfford = checkUserBalance(user_id, amount);
    return res.json({ approved: canAfford });
  }

  if (type === "charge") {
    const txId = processCharge(user_id, amount, order_id);
    return res.json({ success: true, transaction_id: txId });
  }

  res.json({ success: true });
});

# Connect to the Fauri AI agent via WebSocket
import asyncio
import json
import websockets

CLIENT_ID = "your_client_id"
SECRET_KEY = "your_secret_key"
USER_ID = "0x1234...abcd"

async def chat_with_agent():
    uri = (
        f"wss://api.fauri.ai/ws/agent/"
        f"?client_id={CLIENT_ID}"
        f"&secret_key={SECRET_KEY}"
        f"&user_id={USER_ID}"
    )

    async with websockets.connect(uri) as ws:
        # Send a message
        await ws.send(json.dumps({
            "message": "Show me running shoes under $150"
        }))

        # Receive response
        response = await ws.recv()
        data = json.loads(response)
        print(f"Agent: {data['message']}")

        if "products" in data:
            for p in data["products"]:
                print(f"  - {p['name']}: ${p['price']}")

asyncio.run(chat_with_agent())

# REST API usage with requests
import requests

API_URL = "https://api.fauri.ai"
HEADERS = {
    "X-Client-ID": "your_client_id",
    "X-Secret-Key": "your_secret_key",
}

# List all users
def list_users():
    r = requests.get(f"{API_URL}/api/v1/users/", headers=HEADERS)
    return r.json()

# Get chat history for a user
def get_chat_history(user_id: str):
    r = requests.get(
        f"{API_URL}/api/v1/chat/history/?user_id={user_id}",
        headers=HEADERS,
    )
    return r.json()

# Get user orders
def get_user_orders(user_id: str):
    r = requests.get(
        f"{API_URL}/api/v1/users/{user_id}/orders/",
        headers=HEADERS,
    )
    return r.json()

# Create a new user
def create_user(user_id: str, display_name: str = ""):
    r = requests.post(
        f"{API_URL}/api/v1/users/",
        headers={**HEADERS, "Content-Type": "application/json"},
        json={"external_user_id": user_id, "display_name": display_name},
    )
    return r.json()

# Verify webhook signature (Flask)
import hmac
import hashlib
from flask import Flask, request, jsonify

app = Flask(__name__)
WEBHOOK_SECRET = "your_webhook_secret"

def verify_signature(body: bytes, timestamp: str, signature: str) -> bool:
    # Signature is HMAC-SHA256 of "{timestamp}.{body}"
    expected = "sha256=" + hmac.new(
        WEBHOOK_SECRET.encode(),
        f"{timestamp}.{body.decode()}".encode(),
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(signature, expected)

@app.route("/webhooks/kays", methods=["POST"])
def handle_webhook():
    signature = request.headers.get("X-Webhook-Signature", "")
    timestamp = request.headers.get("X-Webhook-Timestamp", "")
    body = request.get_data()

    if not verify_signature(body, timestamp, signature):
        return jsonify({"error": "Invalid signature"}), 401

    payload = request.json
    event_type = payload["type"]
    user_id = payload["user_id"]
    amount = payload["amount"]

    if event_type == "balance_check":
        can_afford = check_user_balance(user_id, amount)
        return jsonify({"approved": can_afford})

    if event_type == "charge":
        tx_id = process_charge(user_id, amount)
        return jsonify({"success": True, "transaction_id": tx_id})

    return jsonify({"success": True})