chore: prior run values

Author: turip

.agents/skills/charges/SKILL.md

@@ -459,6 +459,9 @@ Important behavior:
 - stored-at filtering uses `stored_at < cutoff`
 - the cutoff is the run's `StoredAtLT`
 - the service-period end is expected to behave as exclusive in lifecycle tests
+- `GetDetailedRatingForUsage(...)` owns the current-run filtering rule: only realization runs with `ServicePeriodTo < input.ServicePeriodTo` are prior runs; a current run already present on the charge must be ignored rather than stripped by mutating the charge in the caller
+- minimum commitment is final-only for usage-based snapshots; detailed rating ignores it when the current service-period end is before the charge intent service-period end
+- realtime/current totals should ignore minimum commitment before the charge intent service-period end and include it at/after the service-period end
 
 This means late-arriving events can become eligible in later advances if their `stored_at` was previously too new but later falls before the next cutoff.
 
@@ -511,6 +514,7 @@ Use these conventions for lifecycle tests:
 - use `streaming/testutils.WithStoredAt(...)` to simulate late events
 - when testing stored-at cutoffs, remember the predicate is exclusive: an event with `stored_at == StoredAtLT` is excluded, and an event with `stored_at` before `StoredAtLT` is included
 - when testing service-period cutoffs, remember the event-time window is half-open: an event with `event_time == ServicePeriodTo` is excluded
+- prefer `streamingtestutils.NewMockStreamingConnector(...)` plus the real billing rating service when a usage-based rating test should exercise production quantity lookup, pricing, discounts, or commitments end-to-end
 - prefer `clock.FreezeTime(...)` for exact `StoredAtLT` / `AllocateAt` assertions
 - rely on the default billing profile unless the test explicitly needs customer-specific override behavior
 - for credit-only charges (usage-based or flat fee), `Create(...)` itself may return an already-advanced charge — assert the returned charge's status, do not assume it will be `created`

openmeter/billing/charges/usagebased/rating.go

@@ -16,6 +16,7 @@ var _ rating.StandardLineAccessor = (*RateableIntent)(nil)
 type RateableIntent struct {
 	Intent
 
+	ServicePeriod  timeutil.ClosedPeriod
 	MeterValue     alpacadecimal.Decimal
 	CreditsApplied billing.CreditsApplied
 }

openmeter/billing/charges/usagebased/service/creditheninvoice.go

@@ -248,16 +248,15 @@ func (s *CreditThenInvoiceStateMachine) startInvoiceCreatedRun(
 	}
 
 	result, err := s.Runs.CreateRatedRun(ctx, usagebasedrun.CreateRatedRunInput{
-		Charge:                  s.Charge,
-		CustomerOverride:        s.CustomerOverride,
-		FeatureMeter:            s.FeatureMeter,
-		Type:                    runType,
-		StoredAtLT:              storedAtLT,
-		ServicePeriodTo:         servicePeriodTo,
-		LineID:                  lo.ToPtr(input.LineID),
-		IgnoreMinimumCommitment: ignoreMinimumCommitmentForRunType(runType),
-		CreditAllocation:        usagebasedrun.CreditAllocationAvailable,
-		CurrencyCalculator:      s.CurrencyCalculator,
+		Charge:             s.Charge,
+		CustomerOverride:   s.CustomerOverride,
+		FeatureMeter:       s.FeatureMeter,
+		Type:               runType,
+		StoredAtLT:         storedAtLT,
+		ServicePeriodTo:    servicePeriodTo,
+		LineID:             lo.ToPtr(input.LineID),
+		CreditAllocation:   usagebasedrun.CreditAllocationAvailable,
+		CurrencyCalculator: s.CurrencyCalculator,
 	})
 	if err != nil {
 		return err
@@ -275,12 +274,6 @@ func (s *CreditThenInvoiceStateMachine) StartFinalInvoiceRun(ctx context.Context
 	return s.startInvoiceCreatedRun(ctx, input, usagebased.RealizationRunTypeFinalRealization)
 }
 
-func ignoreMinimumCommitmentForRunType(runType usagebased.RealizationRunType) bool {
-	// Partial invoice runs are interim cumulative checkpoints. Minimum commitment is billed only on the
-	// final realization, so partial runs must suppress it during both creation and later snapshotting.
-	return runType == usagebased.RealizationRunTypePartialInvoice
-}
-
 func resolveInvoiceCreatedTrigger(charge usagebased.Charge, billedPeriod timeutil.ClosedPeriod) meta.Trigger {
 	if meta.NormalizeTimestamp(billedPeriod.To).Equal(meta.NormalizeTimestamp(charge.Intent.ServicePeriod.To)) {
 		return meta.TriggerFinalInvoiceCreated
@@ -309,17 +302,15 @@ func (s *CreditThenInvoiceStateMachine) SnapshotInvoiceUsage(ctx context.Context
 
 	storedAtLT := meta.NormalizeTimestamp(currentRun.StoredAtLT)
 
-	ratingResult, err := s.Rater.GetDetailedLinesForUsage(ctx, usagebasedrating.GetDetailedLinesForUsageInput{
-		Charge:                  s.Charge,
-		PriorRuns:               s.Charge.Realizations.Without(currentRun.ID),
-		Customer:                s.CustomerOverride,
-		FeatureMeter:            s.FeatureMeter,
-		ServicePeriodTo:         currentRun.ServicePeriodTo,
-		StoredAtLT:              storedAtLT,
-		IgnoreMinimumCommitment: ignoreMinimumCommitmentForRunType(currentRun.Type),
+	ratingResult, err := s.Rater.GetDetailedRatingForUsage(ctx, usagebasedrating.GetDetailedRatingForUsageInput{
+		Charge:          s.Charge,
+		StoredAtLT:      storedAtLT,
+		ServicePeriodTo: currentRun.ServicePeriodTo,
+		Customer:        s.CustomerOverride,
+		FeatureMeter:    s.FeatureMeter,
 	})
 	if err != nil {
-		return fmt.Errorf("get rating for usage: %w", err)
+		return fmt.Errorf("get detailed rating for usage: %w", err)
 	}
 
 	currentTotals := ratingResult.Totals.RoundToPrecision(s.CurrencyCalculator)

openmeter/billing/charges/usagebased/service/creditheninvoice_test.go

@@ -58,13 +58,3 @@ func TestResolveInvoiceCreatedTrigger(t *testing.T) {
 		require.Equal(t, meta.TriggerFinalInvoiceCreated, trigger)
 	})
 }
-
-func TestIgnoreMinimumCommitmentForRunType(t *testing.T) {
-	t.Run("partial invoice run", func(t *testing.T) {
-		require.True(t, ignoreMinimumCommitmentForRunType(usagebased.RealizationRunTypePartialInvoice))
-	})
-
-	t.Run("final realization run", func(t *testing.T) {
-		require.False(t, ignoreMinimumCommitmentForRunType(usagebased.RealizationRunTypeFinalRealization))
-	})
-}

openmeter/billing/charges/usagebased/service/creditsonly.go

@@ -184,16 +184,15 @@ func (s *CreditsOnlyStateMachine) FinalizeRealizationRun(ctx context.Context) er
 
 	storedAtLT := meta.NormalizeTimestamp(currentRun.StoredAtLT)
 
-	ratingResult, err := s.Rater.GetDetailedLinesForUsage(ctx, usagebasedrating.GetDetailedLinesForUsageInput{
+	ratingResult, err := s.Rater.GetDetailedRatingForUsage(ctx, usagebasedrating.GetDetailedRatingForUsageInput{
 		Charge:          s.Charge,
-		PriorRuns:       s.Charge.Realizations.Without(currentRun.ID),
+		StoredAtLT:      storedAtLT,
+		ServicePeriodTo: currentRun.ServicePeriodTo,
 		Customer:        s.CustomerOverride,
 		FeatureMeter:    s.FeatureMeter,
-		ServicePeriodTo: currentRun.ServicePeriodTo,
-		StoredAtLT:      storedAtLT,
 	})
 	if err != nil {
-		return fmt.Errorf("get rating for usage: %w", err)
+		return fmt.Errorf("get detailed rating for usage: %w", err)
 	}
 
 	currentTotals := ratingResult.Totals.RoundToPrecision(s.CurrencyCalculator)
@@ -219,12 +218,18 @@ func (s *CreditsOnlyStateMachine) FinalizeRealizationRun(ctx context.Context) er
 	}
 	currentRun.DetailedLines = mo.Some(runDetailedLines)
 
-	if _, err := s.Adapter.UpdateRealizationRun(ctx, usagebased.UpdateRealizationRunInput{
+	currentRunBase, err := s.Adapter.UpdateRealizationRun(ctx, usagebased.UpdateRealizationRunInput{
 		ID:              currentRun.ID,
 		StoredAtLT:      mo.Some(storedAtLT),
 		MeteredQuantity: mo.Some(ratingResult.Quantity),
 		Totals:          mo.Some(currentTotals),
-	}); err != nil {
+	})
+	if err != nil {
+		return fmt.Errorf("update realization run: %w", err)
+	}
+	currentRun.RealizationRunBase = currentRunBase
+
+	if err := s.Charge.Realizations.SetRealizationRun(currentRun); err != nil {
 		return fmt.Errorf("update realization run: %w", err)
 	}
 

openmeter/billing/charges/usagebased/service/currenttotals.go

@@ -48,11 +48,14 @@ func (s *service) GetCurrentTotals(ctx context.Context, input usagebased.GetCurr
 		return usagebased.GetCurrentTotalsResult{}, err
 	}
 
+	now := clock.Now()
+
 	dueTotals, err := s.rater.GetTotalsForUsage(ctx, usagebasedrating.GetTotalsForUsageInput{
-		Charge:       charge,
-		Customer:     customerOverride,
-		FeatureMeter: featureMeter,
-		StoredAtLT:   clock.Now(),
+		Charge:                  charge,
+		Customer:                customerOverride,
+		FeatureMeter:            featureMeter,
+		StoredAtLT:              now,
+		IgnoreMinimumCommitment: now.Before(charge.Intent.ServicePeriod.To),
 	})
 	if err != nil {
 		return usagebased.GetCurrentTotalsResult{}, fmt.Errorf("get totals for usage: %w", err)

openmeter/billing/charges/usagebased/service/get.go

@@ -144,10 +144,11 @@ func (s *service) expandChargesUsage(ctx context.Context, namespace string, char
 
 			var dueTotals totals.Totals
 			dueTotals, err = s.rater.GetTotalsForUsage(ctx, usagebasedrating.GetTotalsForUsageInput{
-				Charge:       charge,
-				Customer:     customerOverridesById[charge.GetCustomerID()],
-				FeatureMeter: featureMeter,
-				StoredAtLT:   storedAt,
+				Charge:                  charge,
+				Customer:                customerOverridesById[charge.GetCustomerID()],
+				FeatureMeter:            featureMeter,
+				StoredAtLT:              storedAt,
+				IgnoreMinimumCommitment: storedAt.Before(charge.Intent.ServicePeriod.To),
 			})
 			if err != nil {
 				err = fmt.Errorf("get totals for charge %s: %w", charge.ID, err)