Fix Codex Luna compatibility

Dockerfile

@@ -4,8 +4,11 @@ RUN apk add --no-cache git
 RUN git clone --depth 1 --branch v1.0.0-rc.22 https://github.com/QuantumNous/new-api.git /src
 COPY image_url_compat.go image_url_compat_test.go image_task_compat.go image_task_compat_test.go /src/relay/channel/openai/
 COPY codex-image-b64.patch /tmp/codex-image-b64.patch
-RUN git -C /src apply --unidiff-zero --check /tmp/codex-image-b64.patch \
-    && git -C /src apply --unidiff-zero /tmp/codex-image-b64.patch
+COPY codex-luna-compat.patch /tmp/codex-luna-compat.patch
+RUN git -C /src apply --check /tmp/codex-image-b64.patch \
+    && git -C /src apply /tmp/codex-image-b64.patch \
+    && git -C /src apply --check /tmp/codex-luna-compat.patch \
+    && git -C /src apply /tmp/codex-luna-compat.patch
 
 FROM oven/bun:1 AS web-builder
 
@@ -14,7 +17,7 @@ COPY --from=source /src/web/package.json /src/web/bun.lock ./
 RUN bun install --frozen-lockfile
 COPY --from=source /src/web ./
 COPY --from=source /src/VERSION /build/VERSION
-RUN DISABLE_ESLINT_PLUGIN=true VITE_REACT_APP_VERSION=v1.0.0-rc.22 bun run build
+RUN DISABLE_ESLINT_PLUGIN=true VITE_REACT_APP_VERSION=v1.0.0-rc.22-codex-luna-compat bun run build
 
 FROM golang:1.26.1-alpine AS go-builder
 
@@ -25,7 +28,10 @@ RUN go mod download
 COPY --from=source /src ./
 COPY --from=web-builder /build/web/dist ./web/dist
 RUN go test ./relay/channel/openai \
-    && go build -ldflags "-s -w -X 'github.com/QuantumNous/new-api/common.Version=v1.0.0-rc.22-codex-image-compat'" -o new-api
+    ./relay \
+    ./relay/channel/gemini \
+    ./service/relayconvert/internal/oai_chat \
+    && go build -ldflags "-s -w -X 'github.com/QuantumNous/new-api/common.Version=v1.0.0-rc.22-codex-luna-compat'" -o new-api
 
 FROM debian:bookworm-slim
 
@@ -39,7 +45,7 @@ RUN apt-get update \
 COPY --from=go-builder /build/new-api /new-api
 COPY --from=source /src/LICENSE /src/NOTICE /src/THIRD-PARTY-LICENSES.md /licenses/
 ENV PORT=7860 \
-    VERSION=v1.0.0-rc.22-codex-image-compat \
+    VERSION=v1.0.0-rc.22-codex-luna-compat \
     CODEX_IMAGE_URL_TO_B64=true \
     CODEX_IMAGE_TASK_POLL=true \
     CODEX_IMAGE_TASK_POLL_TIMEOUT_SECONDS=120

README.md

@@ -15,3 +15,9 @@ This Space includes Codex image compatibility by default:
 - asynchronous `202 image.task` responses are polled for up to 120 seconds;
 - final image URLs are converted to `b64_json`;
 - transient image download errors and upstream 5xx responses are retried up to three times without resubmitting the generation task.
+
+It also includes a Codex Luna compatibility layer:
+
+- `gpt-5.6-luna` is always routed to `gemini-3.7-flash-high`;
+- Codex reasoning effort and summary fields are ignored for the Luna alias;
+- incomplete Responses SSE streams are normalized with output/content indexes and content-part lifecycle events required by Codex.

codex-image-b64.patch

@@ -1,13 +1,16 @@
 diff --git a/relay/channel/openai/adaptor.go b/relay/channel/openai/adaptor.go
-index 4f1c4286..c05ef093 100644
+index 3fd2466..9400aa0 100644
 --- a/relay/channel/openai/adaptor.go
 +++ b/relay/channel/openai/adaptor.go
-@@ -624,3 +624 @@ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, request
+@@ -621,15 +621,28 @@ func (a *Adaptor) ConvertOpenAIResponsesRequest(c *gin.Context, info *relaycommo
+ }
+ 
+ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 -	if info.RelayMode == relayconstant.RelayModeAudioTranscription ||
 -		info.RelayMode == relayconstant.RelayModeAudioTranslation ||
 -		(info.RelayMode == relayconstant.RelayModeImagesEdits && !isJSONRequest(c)) {
 +	if info.RelayMode == relayconstant.RelayModeAudioTranscription || info.RelayMode == relayconstant.RelayModeAudioTranslation {
-@@ -628 +626,9 @@ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, request
+ 		return channel.DoFormRequest(a, c, info, requestBody)
 -	} else if info.RelayMode == relayconstant.RelayModeRealtime {
 +	}
 +	if info.RelayMode == relayconstant.RelayModeImagesEdits && !isJSONRequest(c) {
@@ -18,10 +21,10 @@ index 4f1c4286..c05ef093 100644
 +		return resolveOpenAIImageTask(c, info, response)
 +	}
 +	if info.RelayMode == relayconstant.RelayModeRealtime {
-@@ -630,2 +635,0 @@ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, request
+ 		return channel.DoWssRequest(a, c, info, requestBody)
 -	} else {
 -		return channel.DoApiRequest(a, c, info, requestBody)
-@@ -632,0 +637,9 @@ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, request
+ 	}
 +
 +	response, err := channel.DoApiRequest(a, c, info, requestBody)
 +	if err != nil {
@@ -31,11 +34,17 @@ index 4f1c4286..c05ef093 100644
 +		return resolveOpenAIImageTask(c, info, response)
 +	}
 +	return response, nil
+ }
+ 
+ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *types.NewAPIError) {
 diff --git a/relay/channel/openai/relay_image.go b/relay/channel/openai/relay_image.go
-index 1e6be0dd..240e6eca 100644
+index e0f09aa..f9372d7 100644
 --- a/relay/channel/openai/relay_image.go
 +++ b/relay/channel/openai/relay_image.go
-@@ -41,0 +42,10 @@ func OpenaiImageHandler(c *gin.Context, info *relaycommon.RelayInfo, resp *http.
+@@ -39,6 +39,16 @@ func OpenaiImageHandler(c *gin.Context, info *relaycommon.RelayInfo, resp *http.
+ 		return nil, types.NewOpenAIError(err, types.ErrorCodeReadResponseBodyFailed, http.StatusInternalServerError)
+ 	}
+ 
 +	responseBody, compatStats, err := convertOpenAIImageURLsToBase64(responseBody, downloadOpenAIImageURLCompat)
 +	if err != nil {
 +		return nil, types.NewOpenAIError(err, types.ErrorCodeBadResponseBody, http.StatusBadGateway)
@@ -46,3 +55,6 @@ index 1e6be0dd..240e6eca 100644
 +		logger.LogInfo(c, compatStats.LogMessage())
 +	}
 +
+ 	var usageResp dto.SimpleResponse
+ 	err = common.Unmarshal(responseBody, &usageResp)
+ 	if err != nil {

codex-luna-compat.patch

@@ -0,0 +1,508 @@
+diff --git a/dto/openai_response.go b/dto/openai_response.go
+index 7959f07..a494a7f 100644
+--- a/dto/openai_response.go
++++ b/dto/openai_response.go
+@@ -358,8 +358,10 @@ type ResponsesOutputContent struct {
+ }
+ 
+ type ResponsesReasoningSummaryPart struct {
+-	Type string `json:"type"`
+-	Text string `json:"text"`
++	Type        string        `json:"type"`
++	Text        string        `json:"text"`
++	Annotations []interface{} `json:"annotations,omitempty"`
++	Logprobs    []interface{} `json:"logprobs,omitempty"`
+ }
+ 
+ const (
+@@ -387,6 +389,8 @@ type ResponsesStreamResponse struct {
+ 	Type     string                   `json:"type"`
+ 	Response *OpenAIResponsesResponse `json:"response,omitempty"`
+ 	Delta    string                   `json:"delta,omitempty"`
++	Text     string                   `json:"text,omitempty"`
++	Logprobs []interface{}            `json:"logprobs,omitempty"`
+ 	Item     *ResponsesOutput         `json:"item,omitempty"`
+ 	// - response.function_call_arguments.delta
+ 	// - response.function_call_arguments.done
+diff --git a/relay/channel/openai/relay_responses.go b/relay/channel/openai/relay_responses.go
+index 697cc96..299247f 100644
+--- a/relay/channel/openai/relay_responses.go
++++ b/relay/channel/openai/relay_responses.go
+@@ -84,6 +84,10 @@ func OaiResponsesStreamHandler(c *gin.Context, info *relaycommon.RelayInfo, resp
+ 	var responseTextBuilder strings.Builder
+ 	imageCounter := &relaycommon.ImageGenerationCallCounter{}
+ 	imageCommitted := false
++	var codexCompat *codexResponsesStreamState
++	if info.OriginModelName == codexLunaOriginModel {
++		codexCompat = newCodexResponsesStreamState()
++	}
+ 
+ 	helper.StreamScannerHandler(c, resp, info, func(data string, sr *helper.StreamResult) {
+ 
+@@ -94,7 +98,34 @@ func OaiResponsesStreamHandler(c *gin.Context, info *relaycommon.RelayInfo, resp
+ 			sr.Error(err)
+ 			return
+ 		}
+-		sendResponsesStreamData(c, streamResponse, data)
++		if codexCompat != nil {
++			before, normalized, after, err := codexCompat.normalize(&streamResponse, data)
++			if err != nil {
++				logger.LogError(c, "failed to normalize Codex responses stream: "+err.Error())
++				sr.Error(err)
++				return
++			}
++			for _, injected := range before {
++				injectedData, err := marshalCodexStreamEvent(injected)
++				if err != nil {
++					sr.Error(err)
++					return
++				}
++				sendResponsesStreamData(c, injected, injectedData)
++			}
++			data = normalized
++			sendResponsesStreamData(c, streamResponse, data)
++			for _, injected := range after {
++				injectedData, err := marshalCodexStreamEvent(injected)
++				if err != nil {
++					sr.Error(err)
++					return
++				}
++				sendResponsesStreamData(c, injected, injectedData)
++			}
++		} else {
++			sendResponsesStreamData(c, streamResponse, data)
++		}
+ 		switch streamResponse.Type {
+ 		case "response.completed", "response.done":
+ 			if streamResponse.Response != nil {
+diff --git a/relay/channel/openai/responses_codex_compat.go b/relay/channel/openai/responses_codex_compat.go
+new file mode 100644
+index 0000000..cb18b81
+--- /dev/null
++++ b/relay/channel/openai/responses_codex_compat.go
+@@ -0,0 +1,170 @@
++package openai
++
++import (
++	"fmt"
++	"strings"
++
++	"github.com/QuantumNous/new-api/common"
++	"github.com/QuantumNous/new-api/dto"
++	"github.com/tidwall/gjson"
++	"github.com/tidwall/sjson"
++)
++
++const codexLunaOriginModel = "gpt-5.6-luna"
++
++type codexResponsesStreamState struct {
++	nextOutputIndex  int
++	outputIndexByID  map[string]int
++	contentStartedBy map[string]bool
++	contentDoneBy    map[string]bool
++	textByID         map[string]*strings.Builder
++}
++
++func newCodexResponsesStreamState() *codexResponsesStreamState {
++	return &codexResponsesStreamState{
++		outputIndexByID:  make(map[string]int),
++		contentStartedBy: make(map[string]bool),
++		contentDoneBy:    make(map[string]bool),
++		textByID:         make(map[string]*strings.Builder),
++	}
++}
++
++func (s *codexResponsesStreamState) normalize(
++	event *dto.ResponsesStreamResponse,
++	data string,
++) (before []dto.ResponsesStreamResponse, normalized string, after []dto.ResponsesStreamResponse, err error) {
++	if s == nil || event == nil || data == "" {
++		return nil, data, nil, nil
++	}
++
++	itemID := event.ItemID
++	if itemID == "" && event.Item != nil {
++		itemID = event.Item.ID
++	}
++
++	outputIndex := event.OutputIndex
++	if event.Type == dto.ResponsesOutputTypeItemAdded && itemID != "" {
++		if outputIndex == nil {
++			idx := s.nextOutputIndex
++			s.nextOutputIndex++
++			outputIndex = codexIntPtr(idx)
++		} else if *outputIndex >= s.nextOutputIndex {
++			s.nextOutputIndex = *outputIndex + 1
++		}
++		s.outputIndexByID[itemID] = *outputIndex
++	}
++	if outputIndex == nil && itemID != "" {
++		if idx, ok := s.outputIndexByID[itemID]; ok {
++			outputIndex = codexIntPtr(idx)
++		}
++	}
++	if outputIndex != nil && event.OutputIndex == nil {
++		event.OutputIndex = outputIndex
++		data, err = sjson.Set(data, "output_index", *outputIndex)
++		if err != nil {
++			return nil, "", nil, fmt.Errorf("set responses output_index: %w", err)
++		}
++	}
++
++	if event.Type == dto.ResponsesOutputTypeItemAdded && event.Item != nil && event.Item.Type == "message" {
++		if !gjson.Get(data, "item.content").Exists() {
++			data, err = sjson.SetRaw(data, "item.content", "[]")
++			if err != nil {
++				return nil, "", nil, fmt.Errorf("set responses message content: %w", err)
++			}
++		}
++	}
++
++	switch event.Type {
++	case "response.content_part.added":
++		s.contentStartedBy[itemID] = true
++	case "response.content_part.done":
++		s.contentDoneBy[itemID] = true
++	case "response.output_text.delta":
++		data, err = ensureCodexContentIndex(event, data)
++		if err != nil {
++			return nil, "", nil, err
++		}
++		if !s.contentStartedBy[itemID] {
++			before = append(before, codexContentPartEvent("response.content_part.added", itemID, outputIndex, ""))
++			s.contentStartedBy[itemID] = true
++		}
++		builder := s.textByID[itemID]
++		if builder == nil {
++			builder = &strings.Builder{}
++			s.textByID[itemID] = builder
++		}
++		builder.WriteString(event.Delta)
++	case "response.output_text.done":
++		data, err = ensureCodexContentIndex(event, data)
++		if err != nil {
++			return nil, "", nil, err
++		}
++		if !s.contentStartedBy[itemID] {
++			before = append(before, codexContentPartEvent("response.content_part.added", itemID, outputIndex, ""))
++			s.contentStartedBy[itemID] = true
++		}
++		text := gjson.Get(data, "text").String()
++		if builder := s.textByID[itemID]; builder != nil && text == "" {
++			text = builder.String()
++			data, err = sjson.Set(data, "text", text)
++			if err != nil {
++				return nil, "", nil, fmt.Errorf("set responses output text: %w", err)
++			}
++		}
++		if !s.contentDoneBy[itemID] {
++			after = append(after, codexContentPartEvent("response.content_part.done", itemID, outputIndex, text))
++			s.contentDoneBy[itemID] = true
++		}
++	case dto.ResponsesOutputTypeItemDone:
++		if s.contentStartedBy[itemID] && !s.contentDoneBy[itemID] {
++			text := ""
++			if builder := s.textByID[itemID]; builder != nil {
++				text = builder.String()
++			}
++			before = append(before, codexContentPartEvent("response.content_part.done", itemID, outputIndex, text))
++			s.contentDoneBy[itemID] = true
++		}
++	}
++
++	return before, data, after, nil
++}
++
++func ensureCodexContentIndex(event *dto.ResponsesStreamResponse, data string) (string, error) {
++	if event.ContentIndex != nil {
++		return data, nil
++	}
++	event.ContentIndex = codexIntPtr(0)
++	updated, err := sjson.Set(data, "content_index", 0)
++	if err != nil {
++		return "", fmt.Errorf("set responses content_index: %w", err)
++	}
++	return updated, nil
++}
++
++func codexContentPartEvent(eventType, itemID string, outputIndex *int, text string) dto.ResponsesStreamResponse {
++	return dto.ResponsesStreamResponse{
++		Type:         eventType,
++		OutputIndex:  outputIndex,
++		ContentIndex: codexIntPtr(0),
++		ItemID:       itemID,
++		Part: &dto.ResponsesReasoningSummaryPart{
++			Type:        "output_text",
++			Text:        text,
++			Annotations: []interface{}{},
++			Logprobs:    []interface{}{},
++		},
++	}
++}
++
++func marshalCodexStreamEvent(event dto.ResponsesStreamResponse) (string, error) {
++	data, err := common.Marshal(event)
++	if err != nil {
++		return "", err
++	}
++	return string(data), nil
++}
++
++func codexIntPtr(value int) *int {
++	return &value
++}
+diff --git a/relay/channel/openai/responses_codex_compat_test.go b/relay/channel/openai/responses_codex_compat_test.go
+new file mode 100644
+index 0000000..3cb1082
+--- /dev/null
++++ b/relay/channel/openai/responses_codex_compat_test.go
+@@ -0,0 +1,57 @@
++package openai
++
++import (
++	"testing"
++
++	"github.com/QuantumNous/new-api/common"
++	"github.com/QuantumNous/new-api/dto"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++	"github.com/tidwall/gjson"
++)
++
++func TestCodexResponsesStreamStateAddsIndexesAndContentPartEvents(t *testing.T) {
++	state := newCodexResponsesStreamState()
++
++	added := dto.ResponsesStreamResponse{
++		Type: "response.output_item.added",
++		Item: &dto.ResponsesOutput{ID: "item_1", Type: "message", Role: "assistant", Status: "in_progress"},
++	}
++	before, addedData, after, err := state.normalize(&added, `{"type":"response.output_item.added","item":{"id":"item_1","type":"message","role":"assistant","status":"in_progress"},"sequence_number":1}`)
++	require.NoError(t, err)
++	assert.Empty(t, before)
++	assert.Empty(t, after)
++	assert.Equal(t, int64(0), gjson.Get(addedData, "output_index").Int())
++	assert.True(t, gjson.Get(addedData, "item.content").IsArray())
++	assert.Equal(t, int64(1), gjson.Get(addedData, "sequence_number").Int())
++
++	delta := dto.ResponsesStreamResponse{Type: "response.output_text.delta", ItemID: "item_1", Delta: "OK"}
++	before, deltaData, after, err := state.normalize(&delta, `{"type":"response.output_text.delta","item_id":"item_1","delta":"OK","sequence_number":2}`)
++	require.NoError(t, err)
++	require.Len(t, before, 1)
++	assert.Equal(t, "response.content_part.added", before[0].Type)
++	assert.Empty(t, after)
++	assert.Equal(t, int64(0), gjson.Get(deltaData, "output_index").Int())
++	assert.Equal(t, int64(0), gjson.Get(deltaData, "content_index").Int())
++
++	done := dto.ResponsesStreamResponse{Type: "response.output_text.done", ItemID: "item_1"}
++	before, doneData, after, err := state.normalize(&done, `{"type":"response.output_text.done","item_id":"item_1","sequence_number":3}`)
++	require.NoError(t, err)
++	assert.Empty(t, before)
++	require.Len(t, after, 1)
++	assert.Equal(t, "response.content_part.done", after[0].Type)
++	assert.Equal(t, "OK", after[0].Part.Text)
++	assert.Equal(t, "OK", gjson.Get(doneData, "text").String())
++}
++
++func TestMarshalCodexStreamEventIncludesContentPartPayload(t *testing.T) {
++	data, err := marshalCodexStreamEvent(codexContentPartEvent("response.content_part.added", "item_1", codexIntPtr(0), ""))
++	require.NoError(t, err)
++
++	var event dto.ResponsesStreamResponse
++	require.NoError(t, common.Unmarshal([]byte(data), &event))
++	assert.Equal(t, "response.content_part.added", event.Type)
++	assert.Equal(t, "output_text", event.Part.Type)
++	assert.Equal(t, 0, *event.OutputIndex)
++	assert.Equal(t, 0, *event.ContentIndex)
++}
+diff --git a/relay/responses_handler.go b/relay/responses_handler.go
+index 5fa23d0..9c74145 100644
+--- a/relay/responses_handler.go
++++ b/relay/responses_handler.go
+@@ -20,6 +20,25 @@ import (
+ 	"github.com/gin-gonic/gin"
+ )
+ 
++const (
++	codexLunaModel         = "gpt-5.6-luna"
++	codexLunaUpstreamModel = "gemini-3.7-flash-high"
++)
++
++func applyCodexLunaCompatibility(info *relaycommon.RelayInfo, request *dto.OpenAIResponsesRequest) {
++	if info == nil || request == nil || info.OriginModelName != codexLunaModel {
++		return
++	}
++
++	// Luna is a stable Codex-facing alias for an upstream model whose name
++	// already selects the desired thinking level. Do not reinterpret Codex's
++	// reasoning fields or strip the upstream model's -high suffix.
++	info.UpstreamModelName = codexLunaUpstreamModel
++	info.ReasoningEffort = ""
++	request.Model = codexLunaUpstreamModel
++	request.Reasoning = nil
++}
++
+ func ResponsesHelper(c *gin.Context, info *relaycommon.RelayInfo) (newAPIError *types.NewAPIError) {
+ 	info.InitChannelMeta(c)
+ 	if info.RelayMode == relayconstant.RelayModeResponsesCompact {
+@@ -74,6 +93,7 @@ func ResponsesHelper(c *gin.Context, info *relaycommon.RelayInfo) (newAPIError *
+ 	if err != nil {
+ 		return types.NewError(err, types.ErrorCodeChannelModelMappedError, types.ErrOptionWithSkipRetry())
+ 	}
++	applyCodexLunaCompatibility(info, request)
+ 
+ 	adaptor := GetAdaptor(info.ApiType)
+ 	if adaptor == nil {
+diff --git a/relay/responses_luna_compat_test.go b/relay/responses_luna_compat_test.go
+new file mode 100644
+index 0000000..a6f4185
+--- /dev/null
++++ b/relay/responses_luna_compat_test.go
+@@ -0,0 +1,52 @@
++package relay
++
++import (
++	"testing"
++
++	"github.com/QuantumNous/new-api/dto"
++	relaycommon "github.com/QuantumNous/new-api/relay/common"
++	"github.com/stretchr/testify/assert"
++	"github.com/stretchr/testify/require"
++)
++
++func TestApplyCodexLunaCompatibilityPinsUpstreamAndIgnoresReasoning(t *testing.T) {
++	info := &relaycommon.RelayInfo{
++		OriginModelName: codexLunaModel,
++		ChannelMeta: &relaycommon.ChannelMeta{
++			UpstreamModelName: "gemini-3.7-flash-low",
++		},
++		ReasoningEffort: "max",
++	}
++	request := &dto.OpenAIResponsesRequest{
++		Model: "gemini-3.7-flash-low",
++		Reasoning: &dto.Reasoning{
++			Effort:  "max",
++			Summary: "auto",
++		},
++	}
++
++	applyCodexLunaCompatibility(info, request)
++
++	assert.Equal(t, codexLunaUpstreamModel, info.UpstreamModelName)
++	assert.Empty(t, info.ReasoningEffort)
++	assert.Equal(t, codexLunaUpstreamModel, request.Model)
++	require.Nil(t, request.Reasoning)
++}
++
++func TestApplyCodexLunaCompatibilityDoesNotAffectOtherModels(t *testing.T) {
++	reasoning := &dto.Reasoning{Effort: "high", Summary: "auto"}
++	info := &relaycommon.RelayInfo{
++		OriginModelName: "gpt-5.6-sol",
++		ChannelMeta: &relaycommon.ChannelMeta{
++			UpstreamModelName: "gpt-5.6-sol",
++		},
++		ReasoningEffort: "high",
++	}
++	request := &dto.OpenAIResponsesRequest{Model: "gpt-5.6-sol", Reasoning: reasoning}
++
++	applyCodexLunaCompatibility(info, request)
++
++	assert.Equal(t, "gpt-5.6-sol", info.UpstreamModelName)
++	assert.Equal(t, "high", info.ReasoningEffort)
++	assert.Same(t, reasoning, request.Reasoning)
++}
+diff --git a/service/relayconvert/internal/oai_chat/to_oai_responses_resp.go b/service/relayconvert/internal/oai_chat/to_oai_responses_resp.go
+index b3a15ad..31002b3 100644
+--- a/service/relayconvert/internal/oai_chat/to_oai_responses_resp.go
++++ b/service/relayconvert/internal/oai_chat/to_oai_responses_resp.go
+@@ -17,6 +17,8 @@ const (
+ 	responsesEventCreated                  = "response.created"
+ 	responsesEventCompleted                = "response.completed"
+ 	responsesEventIncomplete               = "response.incomplete"
++	responsesEventContentPartAdded         = "response.content_part.added"
++	responsesEventContentPartDone          = "response.content_part.done"
+ 	responsesEventOutputTextDelta          = "response.output_text.delta"
+ 	responsesEventOutputItemAdded          = "response.output_item.added"
+ 	responsesEventOutputItemDone           = "response.output_item.done"
+diff --git a/service/relayconvert/internal/oai_chat/to_oai_responses_resp_test.go b/service/relayconvert/internal/oai_chat/to_oai_responses_resp_test.go
+index a5034a0..6872def 100644
+--- a/service/relayconvert/internal/oai_chat/to_oai_responses_resp_test.go
++++ b/service/relayconvert/internal/oai_chat/to_oai_responses_resp_test.go
+@@ -118,18 +118,23 @@ func TestChatCompletionsStreamToResponsesEventsAggregatesUsageAndToolArgs(t *tes
+ 	})...)
+ 	events = append(events, FinalizeChatCompletionsStreamToResponses(state)...)
+ 
+-	require.Len(t, events, 10)
++	require.Len(t, events, 12)
+ 	assert.Equal(t, responsesEventCreated, events[0].Type)
+-	assert.Equal(t, responsesEventOutputTextDelta, events[2].Type)
+-	assert.Equal(t, "hello", events[2].Payload.Delta)
+-	assert.Equal(t, responsesEventFunctionArgsDelta, events[4].Type)
+-	assert.Equal(t, `{"q":"x"}`, events[4].Payload.Delta)
+-	assert.Equal(t, responsesEventCompleted, events[9].Type)
+-	require.NotNil(t, events[9].Payload.Response)
+-	assert.Equal(t, 6, events[9].Payload.Response.Usage.TotalTokens)
+-	require.Len(t, events[9].Payload.Response.Output, 2)
+-	assert.Equal(t, "hello", events[9].Payload.Response.Output[0].Content[0].Text)
+-	assert.Equal(t, `"{\"q\":\"x\"}"`, string(events[9].Payload.Response.Output[1].Arguments))
++	assert.Equal(t, responsesEventOutputItemAdded, events[1].Type)
++	assert.Equal(t, responsesEventContentPartAdded, events[2].Type)
++	assert.Equal(t, responsesEventOutputTextDelta, events[3].Type)
++	assert.Equal(t, "hello", events[3].Payload.Delta)
++	assert.Equal(t, responsesEventFunctionArgsDelta, events[5].Type)
++	assert.Equal(t, `{"q":"x"}`, events[5].Payload.Delta)
++	assert.Equal(t, "response.output_text.done", events[6].Type)
++	assert.Equal(t, responsesEventContentPartDone, events[7].Type)
++	assert.Equal(t, "hello", events[7].Payload.Part.Text)
++	assert.Equal(t, responsesEventCompleted, events[11].Type)
++	require.NotNil(t, events[11].Payload.Response)
++	assert.Equal(t, 6, events[11].Payload.Response.Usage.TotalTokens)
++	require.Len(t, events[11].Payload.Response.Output, 2)
++	assert.Equal(t, "hello", events[11].Payload.Response.Output[0].Content[0].Text)
++	assert.Equal(t, `"{\"q\":\"x\"}"`, string(events[11].Payload.Response.Output[1].Arguments))
+ }
+ 
+ func mustResponsesEventsFromChatChunk(t *testing.T, state *ChatToResponsesStreamState, chunk *dto.ChatCompletionsStreamResponse) []ChatToResponsesStreamEvent {
+diff --git a/service/relayconvert/internal/oai_chat/to_oai_responses_stream_resp.go b/service/relayconvert/internal/oai_chat/to_oai_responses_stream_resp.go
+index 75c602d..4c3ee45 100644
+--- a/service/relayconvert/internal/oai_chat/to_oai_responses_stream_resp.go
++++ b/service/relayconvert/internal/oai_chat/to_oai_responses_stream_resp.go
+@@ -152,6 +152,18 @@ func (s *ChatToResponsesStreamState) appendTextDelta(delta string) []ChatToRespo
+ 				Content: []dto.ResponsesOutputContent{},
+ 			},
+ 		}))
++		events = append(events, responsesStreamEvent(responsesEventContentPartAdded, dto.ResponsesStreamResponse{
++			Type:         responsesEventContentPartAdded,
++			OutputIndex:  intPtr(s.textOutputIndex),
++			ContentIndex: intPtr(0),
++			ItemID:       s.messageID(),
++			Part: &dto.ResponsesReasoningSummaryPart{
++				Type:        "output_text",
++				Text:        "",
++				Annotations: []interface{}{},
++				Logprobs:    []interface{}{},
++			},
++		}))
+ 	}
+ 	s.text.WriteString(delta)
+ 	events = append(events, responsesStreamEvent(responsesEventOutputTextDelta, dto.ResponsesStreamResponse{
+@@ -251,6 +263,20 @@ func (s *ChatToResponsesStreamState) doneDeltaEvents() []ChatToResponsesStreamEv
+ 			OutputIndex:  intPtr(s.textOutputIndex),
+ 			ContentIndex: intPtr(0),
+ 			ItemID:       s.messageID(),
++			Text:         s.text.String(),
++			Logprobs:     []interface{}{},
++		}))
++		events = append(events, responsesStreamEvent(responsesEventContentPartDone, dto.ResponsesStreamResponse{
++			Type:         responsesEventContentPartDone,
++			OutputIndex:  intPtr(s.textOutputIndex),
++			ContentIndex: intPtr(0),
++			ItemID:       s.messageID(),
++			Part: &dto.ResponsesReasoningSummaryPart{
++				Type:        "output_text",
++				Text:        s.text.String(),
++				Annotations: []interface{}{},
++				Logprobs:    []interface{}{},
++			},
+ 		}))
+ 		events = append(events, responsesStreamEvent(responsesEventOutputItemDone, dto.ResponsesStreamResponse{
+ 			Type:        responsesEventOutputItemDone,