fix: normalize responses replay inputs

Author: james-6-23

api/validation.go

@@ -676,6 +676,13 @@ func ValidateInput() ValidationRule {
 			"image_generation_call":   true,
 			"web_search_call":         true,
 			"compaction":              true,
+			"input_text":              true,
+			"input_image":             true,
+			"output_text":             true,
+			"refusal":                 true,
+			"input_file":              true,
+			"computer_screenshot":     true,
+			"summary_text":            true,
 			"file":                    true,
 			"image":                   true,
 		}

api/validation_test.go

@@ -75,6 +75,26 @@ func TestValidateResponsesAPIRequestAllowsCompactionInputType(t *testing.T) {
 	}
 }
 
+func TestValidateResponsesAPIRequestAllowsOfficialContentInputTypes(t *testing.T) {
+	result := ValidateResponsesAPIRequest(
+		[]byte(`{
+			"model":"gpt-5.4",
+			"input":[
+				{"type":"input_text","text":"hello"},
+				{"type":"input_image","image_url":"https://example.com/cat.png"},
+				{"type":"input_file","file_id":"file_abc"},
+				{"type":"computer_screenshot","image_url":"https://example.com/screen.png"},
+				{"type":"summary_text","text":"summary"}
+			]
+		}`),
+		[]string{"gpt-5.4"},
+	)
+
+	if !result.Valid {
+		t.Fatalf("expected official Responses content input types to be valid, got %#v", result.Errors)
+	}
+}
+
 func TestValidateResponsesAPIRequestMaxOutputTokensCap(t *testing.T) {
 	tests := []struct {
 		name  string

proxy/response_cache.go

@@ -227,14 +227,19 @@ func cacheCompletedResponse(expandedInputRaw []byte, completedData []byte) {
 	inputItems := gjson.ParseBytes(expandedInputRaw)
 	if inputItems.IsArray() {
 		inputItems.ForEach(func(_, v gjson.Result) bool {
-			items = append(items, json.RawMessage(v.Raw))
+			if item, ok := replayableCachedInputItem(v); ok {
+				items = append(items, item)
+			}
 			return true
 		})
 	}
 
-	// 添加响应 output items
+	// 添加响应 output 中真正需要续链的工具上下文；reasoning/message 等
+	// 服务端输出 item 带有 rs_/msg_ id，store=false 时回灌会触发 item not found。
 	output.ForEach(func(_, v gjson.Result) bool {
-		items = append(items, json.RawMessage(v.Raw))
+		if item, ok := replayableCachedOutputItem(v); ok {
+			items = append(items, item)
+		}
 		return true
 	})
 
@@ -243,6 +248,33 @@ func cacheCompletedResponse(expandedInputRaw []byte, completedData []byte) {
 	}
 }
 
+func replayableCachedInputItem(item gjson.Result) (json.RawMessage, bool) {
+	return stripResponseItemID(json.RawMessage(item.Raw))
+}
+
+func replayableCachedOutputItem(item gjson.Result) (json.RawMessage, bool) {
+	if !isCodexToolCallContextType(item.Get("type").String()) {
+		return nil, false
+	}
+	return stripResponseItemID(json.RawMessage(item.Raw))
+}
+
+func stripResponseItemID(raw json.RawMessage) (json.RawMessage, bool) {
+	var item map[string]any
+	if err := json.Unmarshal(raw, &item); err != nil || item == nil {
+		return raw, true
+	}
+	if _, exists := item["id"]; !exists {
+		return raw, true
+	}
+	delete(item, "id")
+	stripped, err := json.Marshal(item)
+	if err != nil {
+		return nil, false
+	}
+	return stripped, true
+}
+
 func isCodexToolCallContextType(typ string) bool {
 	switch typ {
 	case "function_call",

proxy/response_cache_test.go

@@ -16,7 +16,7 @@ func TestCacheCompletedResponseCachesCodexNativeToolCalls(t *testing.T) {
 	resetResponseCacheForTest()
 
 	expandedInput := []byte(`[{"type":"message","role":"user","content":"find a tool"}]`)
-	completed := []byte(`{"type":"response.completed","response":{"id":"resp_native","output":[{"type":"tool_search_call","call_id":"call_search","status":"completed"}]}}`)
+	completed := []byte(`{"type":"response.completed","response":{"id":"resp_native","output":[{"type":"tool_search_call","id":"ts_123","call_id":"call_search","status":"completed"}]}}`)
 
 	cacheCompletedResponse(expandedInput, completed)
 
@@ -27,6 +27,9 @@ func TestCacheCompletedResponseCachesCodexNativeToolCalls(t *testing.T) {
 	if got := gjson.GetBytes(cached[1], "call_id").String(); got != "call_search" {
 		t.Fatalf("cached call_id = %q, want call_search", got)
 	}
+	if got := gjson.GetBytes(cached[1], "id"); got.Exists() {
+		t.Fatalf("cached output item id should be stripped for store=false replay, got %s", got.Raw)
+	}
 }
 
 func TestExpandPreviousResponseUsesCachedCodexNativeToolContext(t *testing.T) {
@@ -129,3 +132,33 @@ func TestCacheCompletedResponseDoesNotCacheNonCallIDToolCalls(t *testing.T) {
 		})
 	}
 }
+
+func TestCacheCompletedResponseSkipsReasoningAndMessageOutputItems(t *testing.T) {
+	resetResponseCacheForTest()
+
+	cacheCompletedResponse(
+		[]byte(`[{"type":"message","id":"msg_input","role":"user","content":"call a tool"}]`),
+		[]byte(`{"type":"response.completed","response":{"id":"resp_reasoning","output":[`+
+			`{"type":"reasoning","id":"rs_0609","encrypted_content":"opaque"},`+
+			`{"type":"message","id":"msg_output","role":"assistant","content":[{"type":"output_text","text":"thinking"}]},`+
+			`{"type":"function_call","id":"fc_123","call_id":"call_abc","name":"lookup","arguments":"{}"}`+
+			`]}}`),
+	)
+
+	cached := getResponseCache("resp_reasoning")
+	if len(cached) != 2 {
+		t.Fatalf("cached items = %d, want input message + function_call only", len(cached))
+	}
+	if typ := gjson.GetBytes(cached[0], "type").String(); typ != "message" {
+		t.Fatalf("cached[0].type = %q, want message", typ)
+	}
+	if id := gjson.GetBytes(cached[0], "id"); id.Exists() {
+		t.Fatalf("cached input id should be stripped, got %s", id.Raw)
+	}
+	if typ := gjson.GetBytes(cached[1], "type").String(); typ != "function_call" {
+		t.Fatalf("cached[1].type = %q, want function_call", typ)
+	}
+	if id := gjson.GetBytes(cached[1], "id"); id.Exists() {
+		t.Fatalf("cached function_call id should be stripped, got %s", id.Raw)
+	}
+}