API & Architecture Reference

POST /api/chat HTTP/1.1
Host: bayar.dev
Content-Type: application/json

{
  "messages": [
    {
      "id": "msg_1",
      "role": "user",
      "parts": [{ "type": "text", "text": "benchmark --latency" }]
    },
    {
      "id": "msg_2",
      "role": "assistant",
      "parts": [{ "type": "text", "text": "[demo] P95 <85ms ..." }]
    },
    {
      "id": "msg_3",
      "role": "user",
      "parts": [{ "type": "text", "text": "architecture --stack" }]
    }
  ]
}

type ChatRequest = {
  messages: {
    // Optional client-side id, echoed nowhere. Max 128 chars.
    id?: string;

    // 'system' is rejected: instructions cannot be injected by a client.
    role: 'user' | 'assistant';

    // 1-32 parts per message. Parts whose type is not 'text' are
    // discarded server-side rather than rejected, so SDK-emitted
    // parts such as 'step-start' are safe to send back verbatim.
    parts: {
      type: string;   // max 64 chars
      text?: string;  // max 4,000 chars
    }[];
  }[];  // 1-100 messages per request
};

curl -N -X POST https://bayar.dev/api/chat \
  -H 'Content-Type: application/json' \
  -d '{
    "messages": [
      {
        "role": "user",
        "parts": [{ "type": "text", "text": "architecture --stack" }]
      }
    ]
  }'

HTTP/1.1 200 OK
content-type: text/event-stream
cache-control: no-cache
x-accel-buffering: no
x-vercel-ai-ui-message-stream: v1
transfer-encoding: chunked

data: {"type":"start"}

data: {"type":"start-step"}

data: {"type":"text-start","id":"msg_0b19..."}

data: {"type":"text-delta","id":"msg_0b19...","delta":"P95"}

data: {"type":"text-delta","id":"msg_0b19...","delta":" <85ms"}

data: {"type":"text-end","id":"msg_0b19..."}

data: {"type":"finish-step"}

data: {"type":"finish","finishReason":"stop"}

data: [DONE]

'use client';

import { useChat } from '@ai-sdk/react';

export function Terminal() {
  // Defaults to POST /api/chat and accumulates the full history client-side.
  const { messages, sendMessage, status, error, stop } = useChat();

  const streaming = status === 'streaming' || status === 'submitted';

  return (
    <>
      {messages.map((m) => (
        <p key={m.id}>
          {m.parts
            .filter((p) => p.type === 'text')
            .map((p) => p.text)
            .join('')}
        </p>
      ))}

      <button onClick={() => sendMessage({ text: 'benchmark --latency' })}>
        run
      </button>

      {/* Aborts the fetch and closes the stream mid-response. */}
      {streaming && <button onClick={stop}>stop</button>}

      {/* 4xx bodies arrive as JSON in error.message. */}
      {error && <p role="alert">{error.message}</p>}
    </>
  );
}

browser  (React client, useChat)
   |
   |  POST /api/chat  ·  full message history  ·  application/json
   v
Next.js route handler  (App Router · maxDuration 30s)
   |
   +-- 1. rate limit   per-identity fixed window · 10/min · 100/day
   |                   checked BEFORE the body is read
   +-- 2. validate     schema check · role allowlist · per-part size caps
   +-- 3. normalise    non-text parts dropped
   |                   context trimmed to 20 messages / 12,000 chars
   +-- 4. stream       Azure AI Foundry · OpenAI-compatible /openai/v1
   |
   v
SSE response to browser
   upstream detail is logged server-side and masked on the wire,
   so provider hostnames and stack traces never reach the client.

                          +--------------------------------------+
  request  ---->  edge PoP |  1. static assets   (immutable, CDN)  |
                           |  2. semantic cache  (normalised key)  |
                           +------------------+-------------------+
                              hit |           | miss
                                  v           v
                       replayed stream    origin route handler
                                                  |
                                                  v
                                            model provider
                                                  |
                            write-through <-------+

  key      = hash(tenant, model, normalised prompt embedding bucket)
  scope    = per-tenant namespace; never shared across tenants
  ttl      = short by default; invalidated on system-prompt change
  bypass   = requests marked non-deterministic, or tenant opt-out

customer cloud account  (Azure or AWS)
  |
  +-- private subnet
  |     +-- bayar.dev gateway        container image, customer-operated
  |     +-- private endpoint  ---->  customer's own model deployment
  |
  +-- Key Vault / KMS               customer-managed keys (BYOK)
  |     +-- encryption at rest and in transit under customer keys
  |     +-- key rotation and revocation stay with the customer
  |
  +-- observability                 logs and metrics stay in-account
  |
  +-- egress                        no data path to a bayar.dev control
                                    plane; licence and image pulls only