[Bug] Antigravity clean EOF manufactures successful final text completion without upstream finish (v8.0.23) #6533

package executor

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/router-for-me/CLIProxyAPI/v8/internal/config"
	cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
	cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
	sdktranslator "github.com/router-for-me/CLIProxyAPI/v8/sdk/translator"
	"github.com/tidwall/gjson"
)

type eofReproLocalTransport struct {
	baseURL string
	base    http.RoundTripper
}

func (r eofReproLocalTransport) RoundTrip(request *http.Request) (*http.Response, error) {
	if request.URL.Scheme+"://"+request.URL.Host != r.baseURL {
		return nil, fmt.Errorf("repro forbids non-local destination")
	}
	return r.base.RoundTrip(request)
}

// This characterization test reproduces the current false-success behavior;
// it is not a proposed regression expectation for the fixed implementation.
func TestPublicReproCleanEOFWithoutUpstreamFinish(t *testing.T) {
	for _, tc := range []struct {
		name      string
		body      string
		abrupt    bool
		wantStop  bool
		wantError bool
	}{
		{
			name:     "partial_text_then_clean_eof_no_finish_no_usage",
			body:     `data: {"response":{"candidates":[{"content":{"parts":[{"text":"The answer is "}]}}],"modelVersion":"gemini-3.7-flash"}}` + "\n\n",
			wantStop: true,
		},
		{
			name:     "partial_text_then_clean_eof_with_usage_no_finish",
			body:     `data: {"response":{"candidates":[{"content":{"parts":[{"text":"The answer is "}]}}],"modelVersion":"gemini-3.7-flash","usageMetadata":{"promptTokenCount":4,"candidatesTokenCount":3,"totalTokenCount":7}}}` + "\n\n",
			wantStop: true,
		},
		{
			name:     "normal_upstream_stop",
			body:     `data: {"response":{"candidates":[{"content":{"parts":[{"text":"The answer is 42."}]},"finishReason":"STOP"}],"modelVersion":"gemini-3.7-flash","usageMetadata":{"promptTokenCount":4,"candidatesTokenCount":5,"totalTokenCount":9}}}` + "\n\n",
			wantStop: true,
		},
		{
			name:      "partial_text_then_transport_error",
			body:      `data: {"response":{"candidates":[{"content":{"parts":[{"text":"The answer is "}]}}],"modelVersion":"gemini-3.7-flash"}}` + "\n\n",
			abrupt:    true,
			wantError: true,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
				w.Header().Set("Content-Type", "text/event-stream")
				_, _ = io.WriteString(w, tc.body)
				w.(http.Flusher).Flush()
				if tc.abrupt {
					conn, _, err := w.(http.Hijacker).Hijack()
					if err == nil {
						_ = conn.Close()
					}
				}
			}))
			defer server.Close()
			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
			defer cancel()
			ctx = context.WithValue(ctx, "cliproxy.roundtripper", eofReproLocalTransport{
				baseURL: server.URL, base: &http.Transport{Proxy: nil},
			})
			executor := NewAntigravityExecutor(&config.Config{})
			result, err := executor.ExecuteStream(ctx, &cliproxyauth.Auth{
				Metadata: map[string]any{
					"access_token": "synthetic-local-test-token",
					"expired":      time.Now().Add(24 * time.Hour).Format(time.RFC3339),
					"project_id":   "synthetic-local-test-project",
				},
				Attributes: map[string]string{"base_url": server.URL},
			}, cliproxyexecutor.Request{
				Model:   "gemini-3.7-flash",
				Payload: []byte(`{"model":"gemini-3.7-flash","messages":[{"role":"user","content":"What is the answer?"}],"stream":true}`),
			}, cliproxyexecutor.Options{
				SourceFormat:   sdktranslator.FormatOpenAI,
				ResponseFormat: sdktranslator.FormatOpenAI,
				Stream:         true,
			})
			if err != nil {
				t.Fatal(err)
			}
			var text strings.Builder
			var finishReason string
			var streamError error
			for chunk := range result.Chunks {
				if chunk.Err != nil {
					streamError = chunk.Err
					continue
				}
				text.WriteString(gjson.GetBytes(chunk.Payload, "choices.0.delta.content").String())
				if value := gjson.GetBytes(chunk.Payload, "choices.0.finish_reason").String(); value != "" {
					finishReason = value
				}
				t.Logf("downstream=%s", chunk.Payload)
			}
			t.Logf("RESULT text=%q finish_reason=%q stream_error=%v", text.String(), finishReason, streamError)
			if (finishReason == "stop") != tc.wantStop {
				t.Fatalf("finish_reason=%q", finishReason)
			}
			if (streamError != nil) != tc.wantError {
				t.Fatalf("stream_error=%v", streamError)
			}
		})
	}
}