refactor: unify empty-output retry logic into shared completionruntime package and normalize protocol adapter boundary.

internal/completionruntime/nonstream.go

@@ -90,7 +90,11 @@ func ExecuteNonStreamWithRetry(ctx context.Context, ds DeepSeekCaller, a *auth.R
 	if startErr != nil {
 		return NonStreamResult{SessionID: start.SessionID, Payload: start.Payload}, startErr
 	}
-	stdReq = start.Request
+	return ExecuteNonStreamStartedWithRetry(ctx, ds, a, start, opts)
+}
+
+func ExecuteNonStreamStartedWithRetry(ctx context.Context, ds DeepSeekCaller, a *auth.RequestAuth, start StartResult, opts Options) (NonStreamResult, *assistantturn.OutputError) {
+	stdReq := start.Request
 	maxAttempts := opts.MaxAttempts
 	if maxAttempts <= 0 {
 		maxAttempts = 3

internal/completionruntime/nonstream_test.go

@@ -91,7 +91,7 @@ func TestExecuteNonStreamWithRetryBuildsCanonicalTurn(t *testing.T) {
 
 func TestExecuteNonStreamWithRetryUsesParentMessageForEmptyRetry(t *testing.T) {
 	ds := &fakeDeepSeekCaller{responses: []*http.Response{
-		sseHTTPResponse(http.StatusOK, `data: {"response_message_id":77,"p":"response/status","v":"FINISHED"}`),
+		sseHTTPResponse(http.StatusOK, `data: {"response_message_id":77,"p":"response/thinking_content","v":"plan"}`),
 		sseHTTPResponse(http.StatusOK, `data: {"response_message_id":78,"p":"response/content","v":"ok"}`),
 	}}
 	stdReq := promptcompat.StandardRequest{

internal/completionruntime/stream_retry.go

@@ -0,0 +1,118 @@
+package completionruntime
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+
+	"ds2api/internal/auth"
+	"ds2api/internal/config"
+	"ds2api/internal/httpapi/openai/shared"
+)
+
+type StreamRetryOptions struct {
+	Surface          string
+	Stream           bool
+	RetryEnabled     bool
+	RetryMaxAttempts int
+	MaxAttempts      int
+	UsagePrompt      string
+}
+
+type StreamRetryHooks struct {
+	ConsumeAttempt  func(resp *http.Response, allowDeferEmpty bool) (terminalWritten bool, retryable bool)
+	Finalize        func(attempts int)
+	ParentMessageID func() int
+	OnRetry         func(attempts int)
+	OnRetryPrompt   func(prompt string)
+	OnRetryFailure  func(status int, message, code string)
+	OnTerminal      func(attempts int)
+}
+
+func ExecuteStreamWithRetry(ctx context.Context, ds DeepSeekCaller, a *auth.RequestAuth, initialResp *http.Response, payload map[string]any, pow string, opts StreamRetryOptions, hooks StreamRetryHooks) {
+	if hooks.ConsumeAttempt == nil {
+		return
+	}
+	surface := strings.TrimSpace(opts.Surface)
+	if surface == "" {
+		surface = "completion"
+	}
+	maxAttempts := opts.MaxAttempts
+	if maxAttempts <= 0 {
+		maxAttempts = 3
+	}
+	retryMax := opts.RetryMaxAttempts
+	if retryMax <= 0 {
+		retryMax = shared.EmptyOutputRetryMaxAttempts()
+	}
+
+	attempts := 0
+	currentResp := initialResp
+	for {
+		terminalWritten, retryable := hooks.ConsumeAttempt(currentResp, opts.RetryEnabled && attempts < retryMax)
+		if terminalWritten {
+			if hooks.OnTerminal != nil {
+				hooks.OnTerminal(attempts)
+			}
+			return
+		}
+		if !retryable || !opts.RetryEnabled || attempts >= retryMax {
+			if hooks.Finalize != nil {
+				hooks.Finalize(attempts)
+			}
+			return
+		}
+
+		attempts++
+		parentMessageID := 0
+		if hooks.ParentMessageID != nil {
+			parentMessageID = hooks.ParentMessageID()
+		}
+		config.Logger.Info("[completion_runtime_empty_retry] attempting synthetic retry", "surface", surface, "stream", opts.Stream, "retry_attempt", attempts, "parent_message_id", parentMessageID)
+		retryPow, powErr := ds.GetPow(ctx, a, maxAttempts)
+		if powErr != nil {
+			config.Logger.Warn("[completion_runtime_empty_retry] retry PoW fetch failed, falling back to original PoW", "surface", surface, "stream", opts.Stream, "retry_attempt", attempts, "error", powErr)
+			retryPow = pow
+		}
+		nextResp, err := ds.CallCompletion(ctx, a, shared.ClonePayloadForEmptyOutputRetry(payload, parentMessageID), retryPow, maxAttempts)
+		if err != nil {
+			if hooks.OnRetryFailure != nil {
+				hooks.OnRetryFailure(http.StatusInternalServerError, "Failed to get completion.", "error")
+			}
+			config.Logger.Warn("[completion_runtime_empty_retry] retry request failed", "surface", surface, "stream", opts.Stream, "retry_attempt", attempts, "error", err)
+			return
+		}
+		if nextResp.StatusCode != http.StatusOK {
+			body, readErr := io.ReadAll(nextResp.Body)
+			if readErr != nil {
+				config.Logger.Warn("[completion_runtime_empty_retry] retry error body read failed", "surface", surface, "stream", opts.Stream, "retry_attempt", attempts, "error", readErr)
+			}
+			closeRetryBody(surface, nextResp.Body)
+			msg := strings.TrimSpace(string(body))
+			if msg == "" {
+				msg = http.StatusText(nextResp.StatusCode)
+			}
+			if hooks.OnRetryFailure != nil {
+				hooks.OnRetryFailure(nextResp.StatusCode, msg, "error")
+			}
+			return
+		}
+		if hooks.OnRetry != nil {
+			hooks.OnRetry(attempts)
+		}
+		if hooks.OnRetryPrompt != nil {
+			hooks.OnRetryPrompt(shared.UsagePromptWithEmptyOutputRetry(opts.UsagePrompt, attempts))
+		}
+		currentResp = nextResp
+	}
+}
+
+func closeRetryBody(surface string, body io.Closer) {
+	if body == nil {
+		return
+	}
+	if err := body.Close(); err != nil {
+		config.Logger.Warn("[completion_runtime_empty_retry] retry response body close failed", "surface", surface, "error", err)
+	}
+}

internal/completionruntime/stream_retry_test.go

@@ -0,0 +1,62 @@
+package completionruntime
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"ds2api/internal/auth"
+	"ds2api/internal/httpapi/openai/shared"
+)
+
+func TestExecuteStreamWithRetryUsesSharedRetryPayloadAndUsagePrompt(t *testing.T) {
+	ds := &fakeDeepSeekCaller{responses: []*http.Response{
+		sseHTTPResponse(http.StatusOK, `data: {"p":"response/content","v":"ok"}`),
+	}}
+	initial := sseHTTPResponse(http.StatusOK, `data: {"response_message_id":77,"p":"response/thinking_content","v":"plan"}`)
+	payload := map[string]any{"prompt": "original prompt"}
+	attemptsSeen := 0
+	retryPrompt := ""
+
+	ExecuteStreamWithRetry(context.Background(), ds, &auth.RequestAuth{}, initial, payload, "pow", StreamRetryOptions{
+		Surface:      "test.stream",
+		Stream:       true,
+		RetryEnabled: true,
+		UsagePrompt:  "original prompt",
+	}, StreamRetryHooks{
+		ConsumeAttempt: func(resp *http.Response, allowDeferEmpty bool) (bool, bool) {
+			defer func() {
+				if err := resp.Body.Close(); err != nil {
+					t.Fatalf("close failed: %v", err)
+				}
+			}()
+			_, _ = io.ReadAll(resp.Body)
+			attemptsSeen++
+			return attemptsSeen == 2, attemptsSeen == 1 && allowDeferEmpty
+		},
+		ParentMessageID: func() int {
+			return 77
+		},
+		OnRetryPrompt: func(prompt string) {
+			retryPrompt = prompt
+		},
+	})
+
+	if attemptsSeen != 2 {
+		t.Fatalf("expected two stream attempts, got %d", attemptsSeen)
+	}
+	if len(ds.payloads) != 1 {
+		t.Fatalf("expected one retry completion call, got %d", len(ds.payloads))
+	}
+	if got := ds.payloads[0]["parent_message_id"]; got != 77 {
+		t.Fatalf("retry parent_message_id mismatch: %#v", got)
+	}
+	if prompt, _ := ds.payloads[0]["prompt"].(string); !strings.Contains(prompt, shared.EmptyOutputRetrySuffix) {
+		t.Fatalf("expected retry suffix in payload prompt, got %q", prompt)
+	}
+	if !strings.Contains(retryPrompt, shared.EmptyOutputRetrySuffix) {
+		t.Fatalf("expected retry suffix in usage prompt, got %q", retryPrompt)
+	}
+}