fix codex responses sse passthrough

Author: joohw

core/internal/buildinfo/buildinfo.go

@@ -4,7 +4,7 @@ import "strings"
 
 // Set at link time via -ldflags (see .goreleaser.yaml).
 var (
-	Version = "dev0.1.99"
+	Version = "dev0.1.100"
 	Commit  = "none"
 	Date    = "unknown"
 )

core/internal/protocol/stream_sse.go

@@ -71,6 +71,32 @@ func streamFlushMaybe(w http.ResponseWriter) func() {
 	return func() {}
 }
 
+// CopyPlaintextSSEToDownstream relays an already-decoded SSE stream without
+// parsing it. This is used for same-protocol proxying, where the safest
+// behavior is to preserve provider-specific event types and lifecycle details.
+func CopyPlaintextSSEToDownstream(ctx context.Context, plaintext io.Reader, w http.ResponseWriter) error {
+	flush := streamFlushMaybe(w)
+	buf := make([]byte, 16*1024)
+	for {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		n, readErr := plaintext.Read(buf)
+		if n > 0 {
+			if _, err := w.Write(buf[:n]); err != nil {
+				return err
+			}
+			flush()
+		}
+		if readErr != nil {
+			if errors.Is(readErr, io.EOF) {
+				return nil
+			}
+			return readErr
+		}
+	}
+}
+
 // TranscodePlaintextSSEToIngress converts egress-shaped SSE plaintext into ingress-shaped SSE (decoder -> IR -> encoder), mirroring Electron transformResponse.
 //
 // prependModel emits an initial message_start event like Electron eventsWithModel.

core/internal/proxy/server.go

@@ -599,7 +599,11 @@ func (s *Server) handleProxy(w http.ResponseWriter, r *http.Request) {
 		capture := &cappedBuffer{limit: maxCallLogBodyBytes}
 		tee := io.TeeReader(buf, capture)
 		var streamErr error
-		streamErr = protocol.TranscodePlaintextSSEToIngress(r.Context(), route.IngressStyle, route.EgressStyle, ir.Model, tee, w)
+		if route.IngressStyle == apistyle.OpenAIResponses && route.EgressStyle == apistyle.OpenAIResponses {
+			streamErr = protocol.CopyPlaintextSSEToDownstream(r.Context(), tee, w)
+		} else {
+			streamErr = protocol.TranscodePlaintextSSEToIngress(r.Context(), route.IngressStyle, route.EgressStyle, ir.Model, tee, w)
+		}
 		if shouldRecordStreamError(streamErr) {
 			trace.setError(streamErr.Error())
 		}

core/internal/proxy/server_test.go

@@ -433,6 +433,55 @@ func wireResponsesUpstreamStore(base string) *profile.Store {
 	}
 }
 
+func TestSameProtocolOpenAIResponsesSSEPassthroughPreservesLifecycle(t *testing.T) {
+	upstreamBody := strings.Join([]string{
+		`event: response.created`,
+		`data: {"type":"response.created","response":{"id":"resp_test","object":"response","model":"gpt-wire","status":"in_progress","output":[]},"sequence_number":0}`,
+		``,
+		`event: response.reasoning_summary_text.delta`,
+		`data: {"type":"response.reasoning_summary_text.delta","delta":"thinking","sequence_number":1}`,
+		``,
+		`event: response.completed`,
+		`data: {"type":"response.completed","response":{"id":"resp_test","object":"response","model":"gpt-wire","status":"completed","output":[],"usage":{"input_tokens":1,"output_tokens":1}},"sequence_number":2}`,
+		``,
+	}, "\n")
+
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/responses" {
+			t.Errorf("unexpected upstream path %q", r.URL.Path)
+		}
+		w.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
+		_, _ = w.Write([]byte(upstreamBody))
+	}))
+	defer up.Close()
+
+	s := NewServer(profile.ProxyConfig{Host: "127.0.0.1", Port: 27483})
+	s.ProfileLoader = func() (*profile.Store, error) { return wireResponsesUpstreamStore(up.URL + "/v1"), nil }
+	ts := httptest.NewServer(s.Server.Handler)
+	defer ts.Close()
+
+	payload := `{"model":"cross-model-id","input":"ping","stream":true}`
+	resp, err := http.Post(ts.URL+"/custom-api/cross-model-id/openai-responses/v1/responses", "application/json", strings.NewReader(payload))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status=%d body=%s", resp.StatusCode, body)
+	}
+	raw := string(body)
+	for _, want := range []string{
+		`event: response.reasoning_summary_text.delta`,
+		`"type":"response.reasoning_summary_text.delta"`,
+		`event: response.completed`,
+		`"type":"response.completed"`,
+	} {
+		if !strings.Contains(raw, want) {
+			t.Fatalf("same-protocol Responses stream lost %s in %s", want, raw)
+		}
+	}
+}
 func TestCrossProtocolOpenAIIngressWithClaudeUpstreamTranscodesJSON(t *testing.T) {
 	var upstreamHits int
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {