relay/
├── client.go          # Client: unified entry point (Chat, Embed, Image, ...)
├── go.mod             # Separate Go module
├── channel/           # 40 provider adaptors (see below)
├── common/            # Adaptor interface + RelayInfo + shared types
├── common_handler/    # Shared response handlers (rerank, etc.)
├── constant/          # API type constants
├── helper/            # SSE streaming + response ID helpers
├── meter/             # Usage metering (tokens, images, audio seconds)
├── realtime/          # WebSocket realtime API connectors
├── relaykit/          # DTO types, reason maps, relay converters
├── relaymode/         # Relay mode constants (chat, embed, image, ...)
├── service/           # Adaptor-to-relaykit bridge utilities
├── setting/           # Global relay settings stubs
├── task/              # Async task types
└── types/             # Price data and shared types

// Client is the unified entry point for all AI API calls.
type Client struct { ... }

// Provider is the high-level interface for AI API providers.
type Provider interface {
    Name() string
    ApiType() int
    Adaptor() common.Adaptor
}

// ChatRequest is the unified chat completion request.
type ChatRequest struct {
    Model       string    `json:"model"`
    Messages    []Message `json:"messages"`
    Temperature *float64  `json:"temperature,omitempty"`
    MaxTokens   *int      `json:"max_tokens,omitempty"`
    Stream      bool      `json:"stream,omitempty"`
    Tools       []Tool    `json:"tools,omitempty"`
    // ...
}

// ChatResponse is the unified chat completion response.
type ChatResponse struct {
    ID       string       `json:"id"`
    Model    string       `json:"model"`
    Choices  []ChatChoice `json:"choices"`
    Usage    meter.Usage  `json:"usage"`
    Provider string       `json:"provider"`
}

// ChatStreamResult holds the stream channel and final usage.
type ChatStreamResult struct {
    Ch    chan ChatStreamChunk
    Usage meter.Usage
}

advancedcustom  ai360       ali          aws          baidu
baidu_v2        claude      cloudflare   codex        cohere
coze            deepseek    dify         gemini       huggingface
jimeng          jina        lingyiwanwu  minimax      mistral
mokaai          moonshot    newapi       ollama       openai
openrouter      palm        perplexity   replicate    siliconflow
sub2api         submodel    tencent      vertex       volcengine
xai             xinference  xunfei       zhipu        zhipu_4v

import (
    "github.com/LingByte/ling-base/relay"
    "github.com/LingByte/ling-base/relay/meter"
    "github.com/LingByte/ling-base/relay/channel/openai"
)

client := relay.New(
    relay.WithProvider(openai.NewProvider("sk-xxx")),
    relay.WithMeter(meter.NewMemoryMeter()),
)

// Synchronous chat
resp, err := client.Chat(ctx, &relay.ChatRequest{
    Model:    "gpt-4o",
    Messages: []relay.Message{{Role: "user", Content: json.RawMessage(`"Hello"`)}},
})

// Streaming chat
result, err := client.ChatStream(ctx, &relay.ChatRequest{
    Model:    "gpt-4o",
    Messages: []relay.Message{{Role: "user", Content: json.RawMessage(`"Tell me a story"`)}},
    Stream:   true,
})
for chunk := range result.Ch {
    fmt.Print(chunk.Delta)
}