update

backend/gemini.go

@@ -0,0 +1,203 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+type scoreAdviceModelResponse struct {
+	AdvisedScore int    `json:"advisedScore"`
+	Reason       string `json:"reason"`
+}
+
+type geminiGenerateRequest struct {
+	Contents         []geminiContent          `json:"contents"`
+	GenerationConfig geminiGenerationConfig   `json:"generationConfig,omitempty"`
+	SafetySettings   []map[string]interface{} `json:"safetySettings,omitempty"`
+}
+
+type geminiContent struct {
+	Role  string       `json:"role,omitempty"`
+	Parts []geminiPart `json:"parts"`
+}
+
+type geminiPart struct {
+	Text       string            `json:"text,omitempty"`
+	InlineData *geminiInlineData `json:"inline_data,omitempty"`
+}
+
+type geminiInlineData struct {
+	MimeType string `json:"mime_type"`
+	Data     string `json:"data"`
+}
+
+type geminiGenerationConfig struct {
+	Temperature      float64 `json:"temperature,omitempty"`
+	ResponseMimeType string  `json:"responseMimeType,omitempty"`
+	MaxOutputTokens  int     `json:"maxOutputTokens,omitempty"`
+}
+
+type geminiGenerateResponse struct {
+	Candidates []struct {
+		Content struct {
+			Parts []struct {
+				Text string `json:"text"`
+			} `json:"parts"`
+		} `json:"content"`
+	} `json:"candidates"`
+	Error *struct {
+		Message string `json:"message"`
+	} `json:"error,omitempty"`
+}
+
+func (a *App) generateScoreAdvice(stage string, playerID int, imageData string, currentScore int) (ScoreAdviceResponse, error) {
+	mimeType, rawBase64, err := parseDataURI(imageData)
+	if err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("invalid proof image data: %w", err)
+	}
+
+	model := strings.TrimSpace(a.cfg.GeminiModel)
+	if model == "" {
+		model = "gemini-2.0-flash"
+	}
+
+	requestPayload := geminiGenerateRequest{
+		Contents: []geminiContent{
+			{
+				Role: "user",
+				Parts: []geminiPart{
+					{Text: scoreAdvicePrompt(stage, currentScore)},
+					{
+						InlineData: &geminiInlineData{
+							MimeType: mimeType,
+							Data:     rawBase64,
+						},
+					},
+				},
+			},
+		},
+		GenerationConfig: geminiGenerationConfig{
+			Temperature:      0,
+			ResponseMimeType: "application/json",
+			MaxOutputTokens:  100,
+		},
+	}
+
+	body, err := json.Marshal(requestPayload)
+	if err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("marshal gemini request: %w", err)
+	}
+
+	endpoint := fmt.Sprintf(
+		"https://generativelanguage.googleapis.com/v1beta/models/%s:generateContent?key=%s",
+		url.PathEscape(model),
+		url.QueryEscape(a.cfg.GeminiAPIKey),
+	)
+
+	req, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewReader(body))
+	if err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("create gemini request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 25 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("call gemini api: %w", err)
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(io.LimitReader(resp.Body, 2_000_000))
+	if err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("read gemini response: %w", err)
+	}
+
+	if resp.StatusCode >= 300 {
+		return ScoreAdviceResponse{}, fmt.Errorf("gemini api status %d: %s", resp.StatusCode, strings.TrimSpace(string(respBody)))
+	}
+
+	var generated geminiGenerateResponse
+	if err := json.Unmarshal(respBody, &generated); err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("decode gemini response: %w", err)
+	}
+	if generated.Error != nil && strings.TrimSpace(generated.Error.Message) != "" {
+		return ScoreAdviceResponse{}, fmt.Errorf("gemini api error: %s", generated.Error.Message)
+	}
+	if len(generated.Candidates) == 0 || len(generated.Candidates[0].Content.Parts) == 0 {
+		return ScoreAdviceResponse{}, fmt.Errorf("gemini returned no advice")
+	}
+
+	rawText := strings.TrimSpace(generated.Candidates[0].Content.Parts[0].Text)
+	jsonText := extractJSONObject(rawText)
+	if jsonText == "" {
+		return ScoreAdviceResponse{}, fmt.Errorf("gemini response was not valid json")
+	}
+
+	var modelResponse scoreAdviceModelResponse
+	if err := json.Unmarshal([]byte(jsonText), &modelResponse); err != nil {
+		return ScoreAdviceResponse{}, fmt.Errorf("parse gemini advice json: %w", err)
+	}
+
+	return a.buildAdviceResponse(stage, playerID, modelResponse), nil
+}
+
+func parseDataURI(dataURI string) (string, string, error) {
+	value := strings.TrimSpace(dataURI)
+	if !strings.HasPrefix(value, "data:") {
+		return "", "", fmt.Errorf("expected data uri")
+	}
+
+	parts := strings.SplitN(value, ",", 2)
+	if len(parts) != 2 {
+		return "", "", fmt.Errorf("invalid data uri format")
+	}
+
+	header := parts[0]
+	payload := strings.TrimSpace(parts[1])
+	if payload == "" {
+		return "", "", fmt.Errorf("empty data uri payload")
+	}
+
+	mimeType := "image/jpeg"
+	if semicolon := strings.Index(header, ";"); semicolon > len("data:") {
+		mimeType = strings.TrimSpace(header[len("data:"):semicolon])
+	}
+	if mimeType == "" {
+		mimeType = "image/jpeg"
+	}
+
+	return mimeType, payload, nil
+}
+
+func extractJSONObject(raw string) string {
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		return ""
+	}
+	if strings.HasPrefix(text, "```") {
+		text = strings.TrimPrefix(text, "```json")
+		text = strings.TrimPrefix(text, "```")
+		text = strings.TrimSuffix(strings.TrimSpace(text), "```")
+		text = strings.TrimSpace(text)
+	}
+	start := strings.Index(text, "{")
+	end := strings.LastIndex(text, "}")
+	if start == -1 || end == -1 || end <= start {
+		return ""
+	}
+	return strings.TrimSpace(text[start : end+1])
+}
+
+func scoreAdvicePrompt(stage string, currentScore int) string {
+	return fmt.Sprintf(`Target scoring assistant.
+Stage: %s. Current score: %d.
+Return STRICT JSON only:
+{"advisedScore":<int 0..9999>,"reason":"<max 18 words>"}
+Do not add markdown or extra fields.`, stage, currentScore)
+}