Integrate Praxa from your backend framework

Browser or mobile client
        |
        | authenticated application request
        v
Your backend route or Worker
        |
        | server-only Praxa credential
        v
Praxa API or Integration Gateway

app.post("/api/tasks", requireSession, async (request, response, next) => {
  try {
    const input = request.body?.input;
    if (typeof input !== "string" || input.length < 1 || input.length > 16_000) {
      return response.status(400).json({ error: "Invalid task input" });
    }

    const idempotencyKey = await idempotencyKeyFor(
      request.user.id,
      request.body.requestId,
    );
    const upstream = await fetch("https://api.praxa.io/v1/execute", {
      method: "POST",
      headers: {
        authorization: `Bearer ${process.env.PRAXA_API_KEY}`,
        "content-type": "application/json",
        "idempotency-key": idempotencyKey,
      },
      body: JSON.stringify({
        apiVersion: "v1",
        requestId: idempotencyKey,
        mode: "task",
        task: { input },
        idempotencyKey,
      }),
    });
    response.status(upstream.status).send(await upstream.text());
  } catch (error) {
    next(error);
  }
});

type Env = { PRAXA_API_KEY: string };

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const principal = await authenticateApplicationRequest(request, env);
    if (!principal) return new Response("Unauthorized", { status: 401 });

    const { input, requestId } = await request.json<{
      input: string;
      requestId: string;
    }>();
    if (!input || input.length > 16_000) {
      return new Response("Invalid input", { status: 400 });
    }

    const idempotencyKey = await idempotencyKeyFor(principal.id, requestId);
    return fetch("https://api.praxa.io/v1/execute", {
      method: "POST",
      headers: {
        authorization: `Bearer ${env.PRAXA_API_KEY}`,
        "content-type": "application/json",
        "idempotency-key": idempotencyKey,
      },
      body: JSON.stringify({
        apiVersion: "v1",
        requestId: idempotencyKey,
        mode: "task",
        task: { input },
        idempotencyKey,
      }),
    });
  },
};

import os
import hashlib
import httpx
from fastapi import Depends, FastAPI, HTTPException
from pydantic import BaseModel, Field

app = FastAPI()

class TaskInput(BaseModel):
    input: str = Field(min_length=1, max_length=16_000)
    request_id: str = Field(
        alias="requestId",
        min_length=16,
        max_length=128,
        pattern=r"^[A-Za-z0-9][A-Za-z0-9._:-]{15,127}$",
    )

@app.post("/api/tasks")
async def create_task(body: TaskInput, user=Depends(require_user)):
    digest = hashlib.sha256(f"{user.id}\0{body.request_id}".encode()).hexdigest()
    key = f"task:{digest}"
    async with httpx.AsyncClient(timeout=30) as client:
        response = await client.post(
            "https://api.praxa.io/v1/execute",
            headers={
                "Authorization": f"Bearer {os.environ['PRAXA_API_KEY']}",
                "Idempotency-Key": key,
            },
            json={
                "apiVersion": "v1",
                "requestId": key,
                "mode": "task",
                "task": {"input": body.input},
                "idempotencyKey": key,
            },
        )
    if response.status_code >= 400:
        raise HTTPException(response.status_code, response.text)
    return response.json()

export async function startTask(input: string) {
  const response = await fetch("/api/tasks", {
    method: "POST",
    credentials: "same-origin",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ input, requestId: crypto.randomUUID() }),
  });
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}