main.go

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

var (
	bearerToken string
	productId   string
	port        string
)

func init() {
	flag.StringVar(&bearerToken, "token", "", "Bearer token for authentication (required)")
	flag.StringVar(&productId, "id", "", "Product ID (required)")
	flag.StringVar(&port, "port", "8080", "Port to run the server on")
}

func main() {
	flag.Parse()
	if bearerToken == "" || productId == "" {
		fmt.Fprintln(os.Stderr, "Error: -token and -id are required arguments")
		flag.Usage()
		os.Exit(1)
	}

	http.HandleFunc("/v1/models", listModels)
	http.HandleFunc("/v1/chat/completions", chatCompletions)
	fmt.Println("Server started on port", port)
	http.ListenAndServe(":"+port, nil)
}

func chatCompletions(w http.ResponseWriter, r *http.Request) {
	upstreamURL := "https://api.infomaniak.com/1/ai/" + productId + "/openai/chat/completions"

	req, err := http.NewRequest(r.Method, upstreamURL, r.Body)
	if err != nil {
		http.Error(w, "Failed to create upstream request", http.StatusInternalServerError)
		return
	}
	req.Header.Set("Authorization", "Bearer "+bearerToken)
	req.Header.Set("Content-Type", r.Header.Get("Content-Type"))

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		http.Error(w, "Upstream API error", http.StatusBadGateway)
		return
	}
	defer resp.Body.Close()

	for k, vv := range resp.Header {
		for _, v := range vv {
			w.Header().Add(k, v)
		}
	}
	w.WriteHeader(resp.StatusCode)

	io.Copy(w, resp.Body)
}

func listModels(w http.ResponseWriter, r *http.Request) {
	req, err := http.NewRequest("GET", "https://api.infomaniak.com/1/ai/models", nil)
	if err != nil {
		http.Error(w, "Failed to create request", http.StatusInternalServerError)
		return
	}
	req.Header.Set("Authorization", "Bearer "+bearerToken)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil || resp.StatusCode != http.StatusOK {
		http.Error(w, "Upstream API error", http.StatusBadGateway)
		return
	}
	defer resp.Body.Close()

	var upstream struct {
		Result string `json:"result"`
		Data   []struct {
			ID                int         `json:"id"`
			Name              string      `json:"name"`
			Type              string      `json:"type"`
			DocumentationLink string      `json:"documentation_link"`
			Description       string      `json:"description"`
			InfoStatus        string      `json:"info_status"`
			LogoURL           string      `json:"logo_url"`
			LastUpdatedAt     string      `json:"last_updated_at"`
			MaxTokenInput     interface{} `json:"max_token_input"`
			Version           string      `json:"version"`
		} `json:"data"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&upstream); err != nil {
		http.Error(w, "Invalid JSON from upstream", http.StatusInternalServerError)
		return
	}

	type Model struct {
		ID      string `json:"id"`
		Object  string `json:"object"`
		Created int64  `json:"created"`
		OwnedBy string `json:"owned_by"`
	}
	var filtered []Model
	now := time.Now().Unix()
	for _, model := range upstream.Data {
		if model.Type == "llm" {
			filtered = append(filtered, Model{
				ID:      model.Name,
				Object:  "model",
				Created: now,
				OwnedBy: "library",
			})
		}
	}

	out := struct {
		Object string  `json:"object"`
		Data   []Model `json:"data"`
	}{
		Object: "list",
		Data:   filtered,
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(out)
}