knowledge-governance/internal/qaopsai/client.go

// Package qaopsai owns independent governance-side model jobs, never production chat writes.
package qaopsai

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)

var ErrUnavailable = errors.New("qa_ai_unavailable")
var ErrInvalid = errors.New("qa_ai_invalid_request")
var ErrConflict = errors.New("qa_ai_version_conflict")

type RemoteError struct {
	RetryAfter time.Duration
	Code       string
	Retryable  bool
}

func (e *RemoteError) Error() string { return "qa_ai_" + e.Code }

type Client struct{ AllowPrivate, DNSOverTLS bool }
type Completion struct{ Content, Model string }

func (c Client) Call(ctx context.Context, base, model, key, system string, input any, maxTokens int) (Completion, error) {
	endpoint, err := url.Parse(base)
	if err != nil || endpoint.Host == "" || endpoint.User != nil || endpoint.RawQuery != "" || endpoint.Fragment != "" || (endpoint.Scheme != "https" && !(endpoint.Scheme == "http" && c.AllowPrivate)) || strings.TrimSpace(base) != base || len(base) > 500 || strings.TrimSpace(model) == "" || len(model) > 200 || strings.TrimSpace(key) == "" || len(key) > 4096 || strings.ContainsAny(key, "\r\n") {
		return Completion{}, ErrInvalid
	}
	if err := c.validateHost(endpoint.Hostname()); err != nil {
		return Completion{}, err
	}
	endpoint.Path = strings.TrimRight(endpoint.Path, "/") + "/chat/completions"
	body, err := json.Marshal(input)
	if err != nil || len(body) > 8<<20 {
		return Completion{}, ErrInvalid
	}
	wire, err := json.Marshal(map[string]any{"model": model, "messages": []map[string]string{{"role": "system", "content": system}, {"role": "user", "content": string(body)}}, "response_format": map[string]string{"type": "json_object"}, "max_tokens": maxTokens, "stream": false})
	if err != nil {
		return Completion{}, ErrInvalid
	}
	request, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint.String(), bytes.NewReader(wire))
	if err != nil {
		return Completion{}, ErrInvalid
	}
	request.Header.Set("Authorization", "Bearer "+key)
	request.Header.Set("Content-Type", "application/json")
	client := &http.Client{Transport: &http.Transport{DialContext: c.safeDial, TLSHandshakeTimeout: 10 * time.Second, ResponseHeaderTimeout: 110 * time.Second}, Timeout: 120 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
	defer client.CloseIdleConnections()
	response, err := client.Do(request)
	if err != nil {
		if errors.Is(err, ErrInvalid) {
			return Completion{}, ErrInvalid
		}
		return Completion{}, &RemoteError{Code: "network_or_timeout", Retryable: true}
	}
	defer response.Body.Close()
	if response.StatusCode < 200 || response.StatusCode >= 300 {
		code := "request_rejected"
		retry := false
		switch {
		case response.StatusCode == 401 || response.StatusCode == 403:
			code = "credentials_rejected"
		case response.StatusCode == 429:
			code = "rate_limited"
			retry = true
		case response.StatusCode >= 500:
			code = "provider_unavailable"
			retry = true
		case response.StatusCode >= 300 && response.StatusCode < 400:
			code = "redirect_rejected"
		}
		var delay time.Duration
		if code == "rate_limited" {
			if seconds, e := strconv.Atoi(response.Header.Get("Retry-After")); e == nil && seconds > 0 {
				delay = time.Duration(seconds) * time.Second
			} else if date, e := http.ParseTime(response.Header.Get("Retry-After")); e == nil {
				delay = time.Until(date)
			}
			if delay < 15*time.Second {
				delay = 15 * time.Second
			}
			if delay > 120*time.Second {
				delay = 120 * time.Second
			}
		}
		return Completion{}, &RemoteError{Code: code, Retryable: retry, RetryAfter: delay}
	}
	raw, err := io.ReadAll(io.LimitReader(response.Body, (4<<20)+1))
	if err != nil || len(raw) > 4<<20 {
		return Completion{}, &RemoteError{Code: "invalid_response"}
	}
	var result struct {
		Model   string `json:"model"`
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
			FinishReason string `json:"finish_reason"`
		} `json:"choices"`
	}
	if json.Unmarshal(raw, &result) == nil && len(result.Choices) == 1 && result.Choices[0].FinishReason == "length" {
		return Completion{}, &RemoteError{Code: "output_truncated", Retryable: true}
	}
	if json.Unmarshal(raw, &result) != nil || len(result.Choices) != 1 || result.Choices[0].FinishReason != "stop" || strings.TrimSpace(result.Choices[0].Message.Content) == "" {
		return Completion{}, &RemoteError{Code: "incomplete_response", Retryable: true}
	}
	return Completion{Content: result.Choices[0].Message.Content, Model: result.Model}, nil
}