// 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 }