refactor: replace history_split with current_input_file configuration

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

internal/httpapi/admin/handler_settings_test.go

@@ -47,7 +47,7 @@ func TestGetSettingsIncludesTokenRefreshInterval(t *testing.T) {
 	}
 }
 
-func TestGetSettingsIncludesHistorySplitDefaults(t *testing.T) {
+func TestGetSettingsIncludesCurrentInputFileDefaults(t *testing.T) {
 	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
 	req := httptest.NewRequest(http.MethodGet, "/admin/settings", nil)
 	rec := httptest.NewRecorder()
@@ -57,13 +57,6 @@ func TestGetSettingsIncludesHistorySplitDefaults(t *testing.T) {
 	}
 	var body map[string]any
 	_ = json.Unmarshal(rec.Body.Bytes(), &body)
-	historySplit, _ := body["history_split"].(map[string]any)
-	if got := boolFrom(historySplit["enabled"]); got {
-		t.Fatalf("expected history_split.enabled=false, body=%v", body)
-	}
-	if got := intFrom(historySplit["trigger_after_turns"]); got != 1 {
-		t.Fatalf("expected history_split.trigger_after_turns=1, got %d body=%v", got, body)
-	}
 	currentInputFile, _ := body["current_input_file"].(map[string]any)
 	if got := boolFrom(currentInputFile["enabled"]); !got {
 		t.Fatalf("expected current_input_file.enabled=true, body=%v", body)
@@ -190,33 +183,6 @@ func TestUpdateSettingsWithoutRuntimeSkipsMergedRuntimeValidation(t *testing.T)
 	}
 }
 
-func TestUpdateSettingsHistorySplit(t *testing.T) {
-	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
-	payload := map[string]any{
-		"history_split": map[string]any{
-			"enabled":             true,
-			"trigger_after_turns": 3,
-		},
-	}
-	b, _ := json.Marshal(payload)
-	req := httptest.NewRequest(http.MethodPut, "/admin/settings", bytes.NewReader(b))
-	rec := httptest.NewRecorder()
-	h.updateSettings(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
-	}
-	snap := h.Store.Snapshot()
-	if snap.HistorySplit.Enabled == nil || !*snap.HistorySplit.Enabled {
-		t.Fatalf("expected history_split.enabled=true, got %#v", snap.HistorySplit.Enabled)
-	}
-	if snap.HistorySplit.TriggerAfterTurns == nil || *snap.HistorySplit.TriggerAfterTurns != 3 {
-		t.Fatalf("expected history_split.trigger_after_turns=3, got %#v", snap.HistorySplit.TriggerAfterTurns)
-	}
-	if snap.CurrentInputFile.Enabled == nil || *snap.CurrentInputFile.Enabled {
-		t.Fatalf("expected history split to disable current_input_file, got %#v", snap.CurrentInputFile.Enabled)
-	}
-}
-
 func TestUpdateSettingsCurrentInputFile(t *testing.T) {
 	h := newAdminTestHandler(t, `{"keys":["k1"],"history_split":{"enabled":true,"trigger_after_turns":2}}`)
 	payload := map[string]any{
@@ -239,8 +205,11 @@ func TestUpdateSettingsCurrentInputFile(t *testing.T) {
 	if snap.CurrentInputFile.MinChars != 12345 {
 		t.Fatalf("expected current_input_file.min_chars=12345, got %#v", snap.CurrentInputFile)
 	}
-	if snap.HistorySplit.Enabled == nil || *snap.HistorySplit.Enabled {
-		t.Fatalf("expected current input file to disable history_split, got %#v", snap.HistorySplit.Enabled)
+	if !h.Store.CurrentInputFileEnabled() {
+		t.Fatal("expected current input file accessor to stay enabled")
+	}
+	if h.Store.HistorySplitEnabled() {
+		t.Fatal("expected history split accessor to stay disabled")
 	}
 }
 
@@ -290,7 +259,7 @@ func TestUpdateSettingsCurrentInputFilePartialUpdatePreservesMinChars(t *testing
 	}
 }
 
-func TestUpdateSettingsRejectsTwoSplitModesEnabled(t *testing.T) {
+func TestUpdateSettingsIgnoresHistorySplitPayload(t *testing.T) {
 	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
 	payload := map[string]any{
 		"history_split": map[string]any{
@@ -306,8 +275,12 @@ func TestUpdateSettingsRejectsTwoSplitModesEnabled(t *testing.T) {
 	req := httptest.NewRequest(http.MethodPut, "/admin/settings", bytes.NewReader(b))
 	rec := httptest.NewRecorder()
 	h.updateSettings(rec, req)
-	if rec.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	snap := h.Store.Snapshot()
+	if snap.CurrentInputFile.Enabled == nil || !*snap.CurrentInputFile.Enabled {
+		t.Fatalf("expected current_input_file to remain enabled, got %#v", snap.CurrentInputFile.Enabled)
 	}
 }
 

internal/httpapi/admin/settings/handler_settings_parse.go

@@ -21,7 +21,7 @@ func boolFrom(v any) bool {
 	}
 }
 
-func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *config.RuntimeConfig, *config.CompatConfig, *config.ResponsesConfig, *config.EmbeddingsConfig, *config.AutoDeleteConfig, *config.HistorySplitConfig, *config.CurrentInputFileConfig, *config.ThinkingInjectionConfig, map[string]string, error) {
+func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *config.RuntimeConfig, *config.CompatConfig, *config.ResponsesConfig, *config.EmbeddingsConfig, *config.AutoDeleteConfig, *config.CurrentInputFileConfig, *config.ThinkingInjectionConfig, map[string]string, error) {
 	var (
 		adminCfg        *config.AdminConfig
 		runtimeCfg      *config.RuntimeConfig
@@ -29,7 +29,6 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		respCfg         *config.ResponsesConfig
 		embCfg          *config.EmbeddingsConfig
 		autoDeleteCfg   *config.AutoDeleteConfig
-		historySplitCfg *config.HistorySplitConfig
 		currentInputCfg *config.CurrentInputFileConfig
 		thinkingInjCfg  *config.ThinkingInjectionConfig
 		aliasMap        map[string]string
@@ -40,7 +39,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["jwt_expire_hours"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("admin.jwt_expire_hours", n, 1, 720, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.JWTExpireHours = n
 		}
@@ -52,33 +51,33 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["account_max_inflight"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.account_max_inflight", n, 1, 256, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.AccountMaxInflight = n
 		}
 		if v, exists := raw["account_max_queue"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.account_max_queue", n, 1, 200000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.AccountMaxQueue = n
 		}
 		if v, exists := raw["global_max_inflight"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.global_max_inflight", n, 1, 200000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.GlobalMaxInflight = n
 		}
 		if v, exists := raw["token_refresh_interval_hours"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.token_refresh_interval_hours", n, 1, 720, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.TokenRefreshIntervalHours = n
 		}
 		if cfg.AccountMaxInflight > 0 && cfg.GlobalMaxInflight > 0 && cfg.GlobalMaxInflight < cfg.AccountMaxInflight {
-			return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("runtime.global_max_inflight must be >= runtime.account_max_inflight")
+			return nil, nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("runtime.global_max_inflight must be >= runtime.account_max_inflight")
 		}
 		runtimeCfg = cfg
 	}
@@ -101,7 +100,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["store_ttl_seconds"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("responses.store_ttl_seconds", n, 30, 86400, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.StoreTTLSeconds = n
 		}
@@ -113,7 +112,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["provider"]; exists {
 			p := strings.TrimSpace(fmt.Sprintf("%v", v))
 			if err := config.ValidateTrimmedString("embeddings.provider", p, false); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.Provider = p
 		}
@@ -139,7 +138,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["mode"]; exists {
 			mode := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", v)))
 			if err := config.ValidateAutoDeleteMode(mode); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			if mode == "" {
 				mode = "none"
@@ -152,25 +151,6 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		autoDeleteCfg = cfg
 	}
 
-	if raw, ok := req["history_split"].(map[string]any); ok {
-		cfg := &config.HistorySplitConfig{}
-		if v, exists := raw["enabled"]; exists {
-			enabled := boolFrom(v)
-			cfg.Enabled = &enabled
-		}
-		if v, exists := raw["trigger_after_turns"]; exists {
-			n := intFrom(v)
-			if err := config.ValidateIntRange("history_split.trigger_after_turns", n, 1, 1000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
-			}
-			cfg.TriggerAfterTurns = &n
-		}
-		if err := config.ValidateHistorySplitConfig(*cfg); err != nil {
-			return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
-		}
-		historySplitCfg = cfg
-	}
-
 	if raw, ok := req["current_input_file"].(map[string]any); ok {
 		cfg := &config.CurrentInputFileConfig{}
 		if v, exists := raw["enabled"]; exists {
@@ -180,18 +160,15 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["min_chars"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("current_input_file.min_chars", n, 0, 100000000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 			}
 			cfg.MinChars = n
 		}
 		if err := config.ValidateCurrentInputFileConfig(*cfg); err != nil {
-			return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+			return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 		}
 		currentInputCfg = cfg
 	}
-	if boolPtrValue(historySplitCfgEnabled(historySplitCfg)) && boolPtrValue(currentInputCfgEnabled(currentInputCfg)) {
-		return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("history_split.enabled and current_input_file.enabled cannot both be true")
-	}
 
 	if raw, ok := req["thinking_injection"].(map[string]any); ok {
 		cfg := &config.ThinkingInjectionConfig{}
@@ -205,23 +182,5 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		thinkingInjCfg = cfg
 	}
 
-	return adminCfg, runtimeCfg, compatCfg, respCfg, embCfg, autoDeleteCfg, historySplitCfg, currentInputCfg, thinkingInjCfg, aliasMap, nil
-}
-
-func historySplitCfgEnabled(cfg *config.HistorySplitConfig) *bool {
-	if cfg == nil {
-		return nil
-	}
-	return cfg.Enabled
-}
-
-func currentInputCfgEnabled(cfg *config.CurrentInputFileConfig) *bool {
-	if cfg == nil {
-		return nil
-	}
-	return cfg.Enabled
-}
-
-func boolPtrValue(v *bool) bool {
-	return v != nil && *v
+	return adminCfg, runtimeCfg, compatCfg, respCfg, embCfg, autoDeleteCfg, currentInputCfg, thinkingInjCfg, aliasMap, nil
 }

internal/httpapi/admin/settings/handler_settings_read.go

@@ -31,10 +31,6 @@ func (h *Handler) getSettings(w http.ResponseWriter, _ *http.Request) {
 		"responses":   snap.Responses,
 		"embeddings":  snap.Embeddings,
 		"auto_delete": snap.AutoDelete,
-		"history_split": map[string]any{
-			"enabled":             h.Store.HistorySplitEnabled(),
-			"trigger_after_turns": h.Store.HistorySplitTriggerAfterTurns(),
-		},
 		"current_input_file": map[string]any{
 			"enabled":   h.Store.CurrentInputFileEnabled(),
 			"min_chars": h.Store.CurrentInputFileMinChars(),

internal/httpapi/admin/settings/handler_settings_write.go

@@ -17,7 +17,7 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	adminCfg, runtimeCfg, compatCfg, responsesCfg, embeddingsCfg, autoDeleteCfg, historySplitCfg, currentInputCfg, thinkingInjCfg, aliasMap, err := parseSettingsUpdateRequest(req)
+	adminCfg, runtimeCfg, compatCfg, responsesCfg, embeddingsCfg, autoDeleteCfg, currentInputCfg, thinkingInjCfg, aliasMap, err := parseSettingsUpdateRequest(req)
 	if err != nil {
 		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": err.Error()})
 		return
@@ -71,26 +71,10 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 			c.AutoDelete.Mode = autoDeleteCfg.Mode
 			c.AutoDelete.Sessions = autoDeleteCfg.Sessions
 		}
-		if historySplitCfg != nil {
-			if historySplitCfg.Enabled != nil {
-				c.HistorySplit.Enabled = historySplitCfg.Enabled
-				if *historySplitCfg.Enabled {
-					disabled := false
-					c.CurrentInputFile.Enabled = &disabled
-				}
-			}
-			if historySplitCfg.TriggerAfterTurns != nil {
-				c.HistorySplit.TriggerAfterTurns = historySplitCfg.TriggerAfterTurns
-			}
-		}
 		if currentInputCfg != nil {
 			if currentInputEnabledSet {
 				c.CurrentInputFile.Enabled = currentInputCfg.Enabled
 			}
-			if currentInputEnabledSet && currentInputCfg.Enabled != nil && *currentInputCfg.Enabled {
-				disabled := false
-				c.HistorySplit.Enabled = &disabled
-			}
 			if currentInputMinCharsSet {
 				c.CurrentInputFile.MinChars = currentInputCfg.MinChars
 			}

internal/httpapi/openai/chat/chat_history_test.go

@@ -272,14 +272,13 @@ func TestChatCompletionsSkipsHistoryWhenDisabled(t *testing.T) {
 	}
 }
 
-func TestChatCompletionsHistorySplitPersistsHistoryText(t *testing.T) {
+func TestChatCompletionsCurrentInputFilePersistsNeutralPrompt(t *testing.T) {
 	historyStore := newTestChatHistoryStore(t)
 	ds := &inlineUploadDSStub{}
 	h := &Handler{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth:        streamStatusAuthStub{},
 		DS:          ds,
@@ -308,19 +307,19 @@ func TestChatCompletionsHistorySplitPersistsHistoryText(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected detail item, got %v", err)
 	}
-	if full.HistoryText == "" {
-		t.Fatalf("expected history text to be persisted")
-	}
-	if !strings.Contains(full.HistoryText, "first user turn") || !strings.Contains(full.HistoryText, "tool result") {
-		t.Fatalf("expected earlier turns in history text, got %q", full.HistoryText)
-	}
-	if strings.Contains(full.HistoryText, "latest user turn") {
-		t.Fatalf("expected latest turn to stay out of persisted history text, got %q", full.HistoryText)
+	if full.HistoryText != "" {
+		t.Fatalf("expected current input file flow to leave history text empty, got %q", full.HistoryText)
 	}
 	if len(ds.uploadCalls) != 1 {
-		t.Fatalf("expected history upload to happen, got %d", len(ds.uploadCalls))
+		t.Fatalf("expected current input upload to happen, got %d", len(ds.uploadCalls))
 	}
-	if full.HistoryText != string(ds.uploadCalls[0].Data) {
-		t.Fatalf("expected persisted history text to match uploaded HISTORY.txt contents")
+	if ds.uploadCalls[0].Filename != "IGNORE.txt" {
+		t.Fatalf("expected IGNORE.txt upload, got %q", ds.uploadCalls[0].Filename)
+	}
+	if len(full.Messages) != 1 {
+		t.Fatalf("expected neutral prompt to be the only persisted message, got %#v", full.Messages)
+	}
+	if !strings.Contains(full.Messages[0].Content, "Answer the latest user request directly.") {
+		t.Fatalf("expected neutral prompt to be persisted, got %#v", full.Messages[0])
 	}
 }

internal/httpapi/openai/chat/handler.go

@@ -42,20 +42,17 @@ func (h *Handler) compatStripReferenceMarkers() bool {
 	return shared.CompatStripReferenceMarkers(h.Store)
 }
 
-func (h *Handler) applyHistorySplit(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
+func (h *Handler) applyCurrentInputFile(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
 	if h == nil {
 		return stdReq, nil
 	}
 	stdReq = shared.ApplyThinkingInjection(h.Store, stdReq)
 	svc := history.Service{Store: h.Store, DS: h.DS}
 	out, err := svc.ApplyCurrentInputFile(ctx, a, stdReq)
-	if err != nil {
-		return stdReq, err
+	if err != nil || out.CurrentInputFileApplied {
+		return out, err
 	}
-	if out.CurrentInputFileApplied {
-		return out, nil
-	}
-	return svc.Apply(ctx, a, out)
+	return out, nil
 }
 
 func (h *Handler) preprocessInlineFileInputs(ctx context.Context, a *auth.RequestAuth, req map[string]any) error {
@@ -91,7 +88,7 @@ func writeOpenAIInlineFileError(w http.ResponseWriter, err error) {
 	files.WriteInlineFileError(w, err)
 }
 
-func mapHistorySplitError(err error) (int, string) {
+func mapCurrentInputFileError(err error) (int, string) {
 	return history.MapError(err)
 }
 

internal/httpapi/openai/chat/handler_chat.go

@@ -68,9 +68,9 @@ func (h *Handler) ChatCompletions(w http.ResponseWriter, r *http.Request) {
 		writeOpenAIError(w, http.StatusBadRequest, err.Error())
 		return
 	}
-	stdReq, err = h.applyHistorySplit(r.Context(), a, stdReq)
+	stdReq, err = h.applyCurrentInputFile(r.Context(), a, stdReq)
 	if err != nil {
-		status, message := mapHistorySplitError(err)
+		status, message := mapCurrentInputFileError(err)
 		writeOpenAIError(w, status, message)
 		return
 	}

internal/httpapi/openai/chat/vercel_prepare_test.go

@@ -87,7 +87,7 @@ func TestStreamLeaseTTL(t *testing.T) {
 	}
 }
 
-func TestHandleVercelStreamPrepareAppliesHistorySplit(t *testing.T) {
+func TestHandleVercelStreamPrepareAppliesCurrentInputFile(t *testing.T) {
 	t.Setenv("VERCEL", "1")
 	t.Setenv("DS2API_VERCEL_INTERNAL_SECRET", "stream-secret")
 
@@ -95,8 +95,7 @@ func TestHandleVercelStreamPrepareAppliesHistorySplit(t *testing.T) {
 	h := &Handler{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusAuthStub{},
 		DS:   ds,
@@ -119,7 +118,7 @@ func TestHandleVercelStreamPrepareAppliesHistorySplit(t *testing.T) {
 		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
 	}
 	if len(ds.uploadCalls) != 1 {
-		t.Fatalf("expected 1 history upload, got %d", len(ds.uploadCalls))
+		t.Fatalf("expected 1 current input upload, got %d", len(ds.uploadCalls))
 	}
 
 	var body map[string]any
@@ -131,11 +130,11 @@ func TestHandleVercelStreamPrepareAppliesHistorySplit(t *testing.T) {
 		t.Fatalf("expected payload object, got %#v", body["payload"])
 	}
 	promptText, _ := payload["prompt"].(string)
-	if !strings.Contains(promptText, "latest user turn") {
-		t.Fatalf("expected latest user turn in prompt, got %s", promptText)
+	if !strings.Contains(promptText, "Answer the latest user request directly.") {
+		t.Fatalf("expected neutral prompt, got %s", promptText)
 	}
-	if strings.Contains(promptText, "first user turn") {
-		t.Fatalf("expected historical turns removed from prompt, got %s", promptText)
+	if strings.Contains(promptText, "first user turn") || strings.Contains(promptText, "latest user turn") {
+		t.Fatalf("expected original turns hidden from prompt, got %s", promptText)
 	}
 	refIDs, _ := payload["ref_file_ids"].([]any)
 	if len(refIDs) == 0 || refIDs[0] != "file-inline-1" {
@@ -143,7 +142,7 @@ func TestHandleVercelStreamPrepareAppliesHistorySplit(t *testing.T) {
 	}
 }
 
-func TestHandleVercelStreamPrepareMapsHistorySplitManagedAuthFailureTo401(t *testing.T) {
+func TestHandleVercelStreamPrepareMapsCurrentInputFileManagedAuthFailureTo401(t *testing.T) {
 	t.Setenv("VERCEL", "1")
 	t.Setenv("DS2API_VERCEL_INTERNAL_SECRET", "stream-secret")
 
@@ -153,8 +152,7 @@ func TestHandleVercelStreamPrepareMapsHistorySplitManagedAuthFailureTo401(t *tes
 	h := &Handler{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusManagedAuthStub{},
 		DS:   ds,

internal/httpapi/openai/chat/vercel_stream.go

@@ -69,9 +69,9 @@ func (h *Handler) handleVercelStreamPrepare(w http.ResponseWriter, r *http.Reque
 		writeOpenAIError(w, http.StatusBadRequest, "stream must be true")
 		return
 	}
-	stdReq, err = h.applyHistorySplit(r.Context(), a, stdReq)
+	stdReq, err = h.applyCurrentInputFile(r.Context(), a, stdReq)
 	if err != nil {
-		status, message := mapHistorySplitError(err)
+		status, message := mapCurrentInputFileError(err)
 		writeOpenAIError(w, status, message)
 		return
 	}

internal/httpapi/openai/history/current_input_file.go

@@ -28,8 +28,7 @@ func (s Service) ApplyCurrentInputFile(ctx context.Context, a *auth.RequestAuth,
 	if index < 0 {
 		return stdReq, nil
 	}
-	historySplitReached := s.Store.HistorySplitEnabled() && wouldSplitHistory(stdReq.Messages, s.Store.HistorySplitTriggerAfterTurns())
-	if len([]rune(text)) < threshold && !historySplitReached {
+	if len([]rune(text)) < threshold {
 		return stdReq, nil
 	}
 	fileText := promptcompat.BuildOpenAICurrentInputContextTranscript(stdReq.Messages)
@@ -84,11 +83,6 @@ func latestUserInputForFile(messages []any) (int, string) {
 	return -1, ""
 }
 
-func wouldSplitHistory(messages []any, triggerAfterTurns int) bool {
-	_, historyMessages := SplitOpenAIHistoryMessages(messages, triggerAfterTurns)
-	return len(historyMessages) > 0
-}
-
 func currentInputFilePrompt() string {
 	return "The current request and prior conversation context have already been provided. Answer the latest user request directly."
 }

internal/httpapi/openai/history/history_split.go

@@ -2,60 +2,21 @@ package history
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"strings"
 
 	"ds2api/internal/auth"
-	dsclient "ds2api/internal/deepseek/client"
 	"ds2api/internal/httpapi/openai/shared"
 	"ds2api/internal/promptcompat"
 )
 
-const (
-	historySplitFilename    = "HISTORY.txt"
-	historySplitContentType = "text/plain; charset=utf-8"
-	historySplitPurpose     = "assistants"
-)
-
 type Service struct {
 	Store shared.ConfigReader
 	DS    shared.DeepSeekCaller
 }
 
+// Apply is retained for legacy compatibility only. The active split path is
+// current input file handling in ApplyCurrentInputFile.
 func (s Service) Apply(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
-	if s.DS == nil || s.Store == nil || a == nil || !s.Store.HistorySplitEnabled() {
-		return stdReq, nil
-	}
-
-	promptMessages, historyMessages := SplitOpenAIHistoryMessages(stdReq.Messages, s.Store.HistorySplitTriggerAfterTurns())
-	if len(historyMessages) == 0 {
-		return stdReq, nil
-	}
-
-	historyText := promptcompat.BuildOpenAIHistoryTranscript(historyMessages)
-	if strings.TrimSpace(historyText) == "" {
-		return stdReq, errors.New("history split produced empty transcript")
-	}
-
-	result, err := s.DS.UploadFile(ctx, a, dsclient.UploadFileRequest{
-		Filename:    historySplitFilename,
-		ContentType: historySplitContentType,
-		Purpose:     historySplitPurpose,
-		Data:        []byte(historyText),
-	}, 3)
-	if err != nil {
-		return stdReq, fmt.Errorf("upload history file: %w", err)
-	}
-	fileID := strings.TrimSpace(result.ID)
-	if fileID == "" {
-		return stdReq, errors.New("upload history file returned empty file id")
-	}
-
-	stdReq.Messages = promptMessages
-	stdReq.HistoryText = historyText
-	stdReq.RefFileIDs = prependUniqueRefFileID(stdReq.RefFileIDs, fileID)
-	stdReq.FinalPrompt, stdReq.ToolNames = promptcompat.BuildOpenAIPrompt(promptMessages, stdReq.ToolsRaw, "", stdReq.ToolChoice, stdReq.Thinking)
 	return stdReq, nil
 }
 

internal/httpapi/openai/history_split_test.go

@@ -60,9 +60,9 @@ func (streamStatusManagedAuthStub) DetermineCaller(_ *http.Request) (*auth.Reque
 
 func (streamStatusManagedAuthStub) Release(_ *auth.RequestAuth) {}
 
-func TestBuildOpenAIHistoryTranscriptUsesInjectedFileWrapper(t *testing.T) {
+func TestBuildOpenAICurrentInputContextTranscriptUsesInjectedFileWrapper(t *testing.T) {
 	_, historyMessages := splitOpenAIHistoryMessages(historySplitTestMessages(), 1)
-	transcript := buildOpenAIHistoryTranscript(historyMessages)
+	transcript := buildOpenAICurrentInputContextTranscript(historyMessages)
 
 	if !strings.HasPrefix(transcript, "[file content end]\n\n") {
 		t.Fatalf("expected injected file wrapper prefix, got %q", transcript)
@@ -107,7 +107,7 @@ func TestSplitOpenAIHistoryMessagesUsesLatestUserTurn(t *testing.T) {
 		t.Fatalf("expected middle user turn to be moved into history, got %s", promptText)
 	}
 
-	historyText := buildOpenAIHistoryTranscript(historyMessages)
+	historyText := buildOpenAICurrentInputContextTranscript(historyMessages)
 	if !strings.Contains(historyText, "middle user turn") {
 		t.Fatalf("expected middle user turn in split history, got %s", historyText)
 	}
@@ -116,13 +116,13 @@ func TestSplitOpenAIHistoryMessagesUsesLatestUserTurn(t *testing.T) {
 	}
 }
 
-func TestApplyHistorySplitSkipsFirstTurn(t *testing.T) {
+func TestApplyCurrentInputFileSkipsShortInputWhenThresholdNotReached(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
+			currentInputMin:     10,
 		},
 		DS: ds,
 	}
@@ -137,9 +137,9 @@ func TestApplyHistorySplitSkipsFirstTurn(t *testing.T) {
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
-		t.Fatalf("apply history split failed: %v", err)
+		t.Fatalf("apply current input file failed: %v", err)
 	}
 	if len(ds.uploadCalls) != 0 {
 		t.Fatalf("expected no upload on first turn, got %d", len(ds.uploadCalls))
@@ -153,10 +153,8 @@ func TestApplyThinkingInjectionAppendsLatestUserPrompt(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
-			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
-			thinkingInjection:   boolPtr(true),
+			wideInput:         true,
+			thinkingInjection: boolPtr(true),
 		},
 		DS: ds,
 	}
@@ -171,7 +169,7 @@ func TestApplyThinkingInjectionAppendsLatestUserPrompt(t *testing.T) {
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
 		t.Fatalf("apply thinking injection failed: %v", err)
 	}
@@ -204,7 +202,7 @@ func TestApplyThinkingInjectionUsesCustomPrompt(t *testing.T) {
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
 		t.Fatalf("apply thinking injection failed: %v", err)
 	}
@@ -213,12 +211,11 @@ func TestApplyThinkingInjectionUsesCustomPrompt(t *testing.T) {
 	}
 }
 
-func TestApplyHistorySplitDirectPassThroughWhenBothSplitsDisabled(t *testing.T) {
+func TestApplyCurrentInputFileDisabledPassThrough(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: false,
 			currentInputEnabled: false,
 		},
 		DS: ds,
@@ -232,9 +229,9 @@ func TestApplyHistorySplitDirectPassThroughWhenBothSplitsDisabled(t *testing.T)
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
-		t.Fatalf("apply history split failed: %v", err)
+		t.Fatalf("apply current input file failed: %v", err)
 	}
 	if len(ds.uploadCalls) != 0 {
 		t.Fatalf("expected no uploads when both split modes are disabled, got %d", len(ds.uploadCalls))
@@ -252,8 +249,6 @@ func TestApplyCurrentInputFileUploadsFirstTurnWithInjectedWrapper(t *testing.T)
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
 			currentInputEnabled: true,
 			currentInputMin:     10,
 			thinkingInjection:   boolPtr(true),
@@ -271,7 +266,7 @@ func TestApplyCurrentInputFileUploadsFirstTurnWithInjectedWrapper(t *testing.T)
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
 		t.Fatalf("apply current input file failed: %v", err)
 	}
@@ -309,15 +304,13 @@ func TestApplyCurrentInputFileUploadsFirstTurnWithInjectedWrapper(t *testing.T)
 	}
 }
 
-func TestApplyCurrentInputFileReplacesHistorySplitWithFullContextFile(t *testing.T) {
+func TestApplyCurrentInputFileUploadsFullContextFile(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
 			currentInputEnabled: true,
-			currentInputMin:     1000,
+			currentInputMin:     0,
 			thinkingInjection:   boolPtr(true),
 		},
 		DS: ds,
@@ -331,12 +324,12 @@ func TestApplyCurrentInputFileReplacesHistorySplitWithFullContextFile(t *testing
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
 		t.Fatalf("apply current input file failed: %v", err)
 	}
 	if !out.CurrentInputFileApplied {
-		t.Fatalf("expected current input file to replace history split")
+		t.Fatalf("expected current input file to apply")
 	}
 	if len(ds.uploadCalls) != 1 {
 		t.Fatalf("expected one current input upload, got %d", len(ds.uploadCalls))
@@ -351,9 +344,6 @@ func TestApplyCurrentInputFileReplacesHistorySplitWithFullContextFile(t *testing
 			t.Fatalf("expected full context file to contain %q, got %q", want, uploadedText)
 		}
 	}
-	if out.HistoryText != "" {
-		t.Fatalf("expected no HISTORY transcript when current input file replaces split, got %q", out.HistoryText)
-	}
 	if strings.Contains(out.FinalPrompt, "first user turn") || strings.Contains(out.FinalPrompt, "latest user turn") || strings.Contains(out.FinalPrompt, "CURRENT_USER_INPUT.txt") || strings.Contains(out.FinalPrompt, "IGNORE.txt") || strings.Contains(out.FinalPrompt, "Read that file") {
 		t.Fatalf("expected live prompt to use only a neutral continuation instruction, got %s", out.FinalPrompt)
 	}
@@ -362,13 +352,12 @@ func TestApplyCurrentInputFileReplacesHistorySplitWithFullContextFile(t *testing
 	}
 }
 
-func TestApplyHistorySplitCarriesHistoryText(t *testing.T) {
+func TestApplyCurrentInputFileLeavesHistoryTextEmpty(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		DS: ds,
 	}
@@ -381,25 +370,24 @@ func TestApplyHistorySplitCarriesHistoryText(t *testing.T) {
 		t.Fatalf("normalize failed: %v", err)
 	}
 
-	out, err := h.applyHistorySplit(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
+	out, err := h.applyCurrentInputFile(context.Background(), &auth.RequestAuth{DeepSeekToken: "token"}, stdReq)
 	if err != nil {
-		t.Fatalf("apply history split failed: %v", err)
+		t.Fatalf("apply current input file failed: %v", err)
 	}
 	if len(ds.uploadCalls) != 1 {
 		t.Fatalf("expected 1 upload call, got %d", len(ds.uploadCalls))
 	}
-	if out.HistoryText != string(ds.uploadCalls[0].Data) {
-		t.Fatalf("expected history text to be preserved on normalized request")
+	if out.HistoryText != "" {
+		t.Fatalf("expected current input file flow to leave history text empty, got %q", out.HistoryText)
 	}
 }
 
-func TestChatCompletionsHistorySplitUploadsHistoryFileAndKeepsLatestPrompt(t *testing.T) {
+func TestChatCompletionsCurrentInputFileUploadsContextAndKeepsNeutralPrompt(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusAuthStub{},
 		DS:   ds,
@@ -423,7 +411,7 @@ func TestChatCompletionsHistorySplitUploadsHistoryFileAndKeepsLatestPrompt(t *te
 		t.Fatalf("expected 1 upload call, got %d", len(ds.uploadCalls))
 	}
 	upload := ds.uploadCalls[0]
-	if upload.Filename != "HISTORY.txt" {
+	if upload.Filename != "IGNORE.txt" {
 		t.Fatalf("unexpected upload filename: %q", upload.Filename)
 	}
 	if upload.Purpose != "assistants" {
@@ -433,32 +421,31 @@ func TestChatCompletionsHistorySplitUploadsHistoryFileAndKeepsLatestPrompt(t *te
 	if !strings.Contains(historyText, "[file content end]") || !strings.Contains(historyText, "[file name]: IGNORE") {
 		t.Fatalf("expected injected IGNORE wrapper, got %s", historyText)
 	}
-	if strings.Contains(historyText, "latest user turn") {
-		t.Fatalf("expected latest turn to remain live, got %s", historyText)
+	if !strings.Contains(historyText, "latest user turn") {
+		t.Fatalf("expected full context to include latest turn, got %s", historyText)
 	}
 	if ds.completionReq == nil {
 		t.Fatal("expected completion payload to be captured")
 	}
 	promptText, _ := ds.completionReq["prompt"].(string)
-	if !strings.Contains(promptText, "latest user turn") {
-		t.Fatalf("expected latest turn in completion prompt, got %s", promptText)
+	if !strings.Contains(promptText, "Answer the latest user request directly.") {
+		t.Fatalf("expected neutral completion prompt, got %s", promptText)
 	}
-	if strings.Contains(promptText, "first user turn") {
-		t.Fatalf("expected historical turns removed from completion prompt, got %s", promptText)
+	if strings.Contains(promptText, "first user turn") || strings.Contains(promptText, "latest user turn") {
+		t.Fatalf("expected prompt to hide original turns, got %s", promptText)
 	}
 	refIDs, _ := ds.completionReq["ref_file_ids"].([]any)
 	if len(refIDs) == 0 || refIDs[0] != "file-inline-1" {
-		t.Fatalf("expected uploaded history file to be first ref_file_id, got %#v", ds.completionReq["ref_file_ids"])
+		t.Fatalf("expected uploaded current input file to be first ref_file_id, got %#v", ds.completionReq["ref_file_ids"])
 	}
 }
 
-func TestResponsesHistorySplitUploadsHistoryAndKeepsLatestPrompt(t *testing.T) {
+func TestResponsesCurrentInputFileUploadsContextAndKeepsNeutralPrompt(t *testing.T) {
 	ds := &inlineUploadDSStub{}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusAuthStub{},
 		DS:   ds,
@@ -487,23 +474,22 @@ func TestResponsesHistorySplitUploadsHistoryAndKeepsLatestPrompt(t *testing.T) {
 		t.Fatal("expected completion payload to be captured")
 	}
 	promptText, _ := ds.completionReq["prompt"].(string)
-	if !strings.Contains(promptText, "latest user turn") {
-		t.Fatalf("expected latest turn in completion prompt, got %s", promptText)
+	if !strings.Contains(promptText, "Answer the latest user request directly.") {
+		t.Fatalf("expected neutral completion prompt, got %s", promptText)
 	}
-	if strings.Contains(promptText, "first user turn") {
-		t.Fatalf("expected historical turns removed from completion prompt, got %s", promptText)
+	if strings.Contains(promptText, "first user turn") || strings.Contains(promptText, "latest user turn") {
+		t.Fatalf("expected prompt to hide original turns, got %s", promptText)
 	}
 }
 
-func TestChatCompletionsHistorySplitMapsManagedAuthFailureTo401(t *testing.T) {
+func TestChatCompletionsCurrentInputFileMapsManagedAuthFailureTo401(t *testing.T) {
 	ds := &inlineUploadDSStub{
 		uploadErr: &dsclient.RequestFailure{Op: "upload file", Kind: dsclient.FailureManagedUnauthorized, Message: "expired token"},
 	}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusManagedAuthStub{},
 		DS:   ds,
@@ -528,15 +514,14 @@ func TestChatCompletionsHistorySplitMapsManagedAuthFailureTo401(t *testing.T) {
 	}
 }
 
-func TestResponsesHistorySplitMapsDirectAuthFailureTo401(t *testing.T) {
+func TestResponsesCurrentInputFileMapsDirectAuthFailureTo401(t *testing.T) {
 	ds := &inlineUploadDSStub{
 		uploadErr: &dsclient.RequestFailure{Op: "upload file", Kind: dsclient.FailureDirectUnauthorized, Message: "invalid token"},
 	}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusAuthStub{},
 		DS:   ds,
@@ -563,13 +548,12 @@ func TestResponsesHistorySplitMapsDirectAuthFailureTo401(t *testing.T) {
 	}
 }
 
-func TestChatCompletionsHistorySplitUploadFailureReturnsInternalServerError(t *testing.T) {
+func TestChatCompletionsCurrentInputFileUploadFailureReturnsInternalServerError(t *testing.T) {
 	ds := &inlineUploadDSStub{uploadErr: errors.New("boom")}
 	h := &openAITestSurface{
 		Store: mockOpenAIConfig{
 			wideInput:           true,
-			historySplitEnabled: true,
-			historySplitTurns:   1,
+			currentInputEnabled: true,
 		},
 		Auth: streamStatusAuthStub{},
 		DS:   ds,
@@ -591,7 +575,7 @@ func TestChatCompletionsHistorySplitUploadFailureReturnsInternalServerError(t *t
 	}
 }
 
-func TestHistorySplitWorksAcrossAutoDeleteModes(t *testing.T) {
+func TestCurrentInputFileWorksAcrossAutoDeleteModes(t *testing.T) {
 	for _, mode := range []string{"none", "single", "all"} {
 		t.Run(mode, func(t *testing.T) {
 			ds := &inlineUploadDSStub{}
@@ -599,8 +583,7 @@ func TestHistorySplitWorksAcrossAutoDeleteModes(t *testing.T) {
 				Store: mockOpenAIConfig{
 					wideInput:           true,
 					autoDeleteMode:      mode,
-					historySplitEnabled: true,
-					historySplitTurns:   1,
+					currentInputEnabled: true,
 				},
 				Auth: streamStatusAuthStub{},
 				DS:   ds,
@@ -621,13 +604,13 @@ func TestHistorySplitWorksAcrossAutoDeleteModes(t *testing.T) {
 				t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
 			}
 			if len(ds.uploadCalls) != 1 {
-				t.Fatalf("expected history split upload for mode=%s, got %d", mode, len(ds.uploadCalls))
+				t.Fatalf("expected current input upload for mode=%s, got %d", mode, len(ds.uploadCalls))
 			}
 			if ds.completionReq == nil {
 				t.Fatalf("expected completion payload for mode=%s", mode)
 			}
 			promptText, _ := ds.completionReq["prompt"].(string)
-			if !strings.Contains(promptText, "latest user turn") || strings.Contains(promptText, "first user turn") {
+			if !strings.Contains(promptText, "Answer the latest user request directly.") || strings.Contains(promptText, "first user turn") || strings.Contains(promptText, "latest user turn") {
 				t.Fatalf("unexpected prompt for mode=%s: %s", mode, promptText)
 			}
 		})

internal/httpapi/openai/responses/handler.go

@@ -36,20 +36,17 @@ func (h *Handler) compatStripReferenceMarkers() bool {
 	return shared.CompatStripReferenceMarkers(h.Store)
 }
 
-func (h *Handler) applyHistorySplit(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
+func (h *Handler) applyCurrentInputFile(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
 	if h == nil {
 		return stdReq, nil
 	}
 	stdReq = shared.ApplyThinkingInjection(h.Store, stdReq)
 	svc := history.Service{Store: h.Store, DS: h.DS}
 	out, err := svc.ApplyCurrentInputFile(ctx, a, stdReq)
-	if err != nil {
-		return stdReq, err
+	if err != nil || out.CurrentInputFileApplied {
+		return out, err
 	}
-	if out.CurrentInputFileApplied {
-		return out, nil
-	}
-	return svc.Apply(ctx, a, out)
+	return out, nil
 }
 
 func (h *Handler) preprocessInlineFileInputs(ctx context.Context, a *auth.RequestAuth, req map[string]any) error {
@@ -89,7 +86,7 @@ func writeOpenAIInlineFileError(w http.ResponseWriter, err error) {
 	files.WriteInlineFileError(w, err)
 }
 
-func mapHistorySplitError(err error) (int, string) {
+func mapCurrentInputFileError(err error) (int, string) {
 	return history.MapError(err)
 }
 

internal/httpapi/openai/responses/responses_handler.go

@@ -85,9 +85,9 @@ func (h *Handler) Responses(w http.ResponseWriter, r *http.Request) {
 		writeOpenAIError(w, http.StatusBadRequest, err.Error())
 		return
 	}
-	stdReq, err = h.applyHistorySplit(r.Context(), a, stdReq)
+	stdReq, err = h.applyCurrentInputFile(r.Context(), a, stdReq)
 	if err != nil {
-		status, message := mapHistorySplitError(err)
+		status, message := mapCurrentInputFileError(err)
 		writeOpenAIError(w, status, message)
 		return
 	}

internal/httpapi/openai/test_bridge_test.go

@@ -83,17 +83,14 @@ func (h *openAITestSurface) ChatCompletions(w http.ResponseWriter, r *http.Reque
 	h.chatHandler().ChatCompletions(w, r)
 }
 
-func (h *openAITestSurface) applyHistorySplit(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
+func (h *openAITestSurface) applyCurrentInputFile(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
 	stdReq = shared.ApplyThinkingInjection(h.Store, stdReq)
 	svc := history.Service{Store: h.Store, DS: h.DS}
 	out, err := svc.ApplyCurrentInputFile(ctx, a, stdReq)
-	if err != nil {
-		return stdReq, err
+	if err != nil || out.CurrentInputFileApplied {
+		return out, err
 	}
-	if out.CurrentInputFileApplied {
-		return out, nil
-	}
-	return svc.Apply(ctx, a, out)
+	return out, nil
 }
 
 func (h *openAITestSurface) preprocessInlineFileInputs(ctx context.Context, a *auth.RequestAuth, req map[string]any) error {
@@ -114,8 +111,8 @@ func splitOpenAIHistoryMessages(messages []any, triggerAfterTurns int) ([]any, [
 	return history.SplitOpenAIHistoryMessages(messages, triggerAfterTurns)
 }
 
-func buildOpenAIHistoryTranscript(messages []any) string {
-	return promptcompat.BuildOpenAIHistoryTranscript(messages)
+func buildOpenAICurrentInputContextTranscript(messages []any) string {
+	return promptcompat.BuildOpenAICurrentInputContextTranscript(messages)
 }
 
 func writeOpenAIError(w http.ResponseWriter, status int, message string) {