Proxy Gateway (Python, Go, n8n)

package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
)

const (
    proxyURL    = "https://proxy.atlasburn.com/openai/v1/chat/completions"
    openaiKey   = "sk-your-real-openai-key"
    atlasKey    = "abn_your_atlasburn_key"
    useStream   = true
)

type ChatRequest struct {
    Model    string        `json:"model"`
    Messages []ChatMessage `json:"messages"`
    Stream   bool          `json:"stream"`
}
type ChatMessage struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}
type ChatResponse struct {
    Choices []struct {
        Message ChatMessage `json:"message"`
    } `json:"choices"`
}

func main() {
    body, _ := json.Marshal(ChatRequest{
        Model:    "gpt-4o",
        Messages: []ChatMessage{{Role: "user", Content: "Hello from Go"}},
        Stream:   useStream,
    })

    req, err := http.NewRequest("POST", proxyURL, bytes.NewBuffer(body))
    if err != nil {
        fmt.Fprintln(os.Stderr, "request build:", err)
        return
    }
    req.Header.Set("Authorization", "Bearer "+openaiKey)
    req.Header.Set("AtlasBurn-API-Key", atlasKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        fmt.Fprintln(os.Stderr, "request:", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode >= 400 {
        msg, _ := io.ReadAll(resp.Body)
        fmt.Fprintf(os.Stderr, "proxy error %d: %s\n", resp.StatusCode, msg)
        return
    }

    // Streaming (SSE) path — provider responds with text/event-stream.
    if strings.HasPrefix(resp.Header.Get("Content-Type"), "text/event-stream") {
        scanner := bufio.NewScanner(resp.Body)
        for scanner.Scan() {
            line := scanner.Text()
            if !strings.HasPrefix(line, "data: ") {
                continue
            }
            payload := strings.TrimPrefix(line, "data: ")
            if payload == "[DONE]" {
                break
            }
            var chunk struct {
                Choices []struct {
                    Delta struct {
                        Content string `json:"content"`
                    } `json:"delta"`
                } `json:"choices"`
            }
            if err := json.Unmarshal([]byte(payload), &chunk); err != nil {
                continue // skip malformed frame
            }
            if len(chunk.Choices) > 0 {
                fmt.Print(chunk.Choices[0].Delta.Content)
            }
        }
        fmt.Println()
        return
    }

    // Non-streaming JSON path.
    var parsed ChatResponse
    if err := json.NewDecoder(resp.Body).Decode(&parsed); err != nil {
        fmt.Fprintln(os.Stderr, "decode:", err)
        return
    }
    if len(parsed.Choices) == 0 {
        fmt.Println("(empty response)")
        return
    }
    fmt.Println(parsed.Choices[0].Message.Content)
}