feat(go): add Resolve and ApplyFlags API to provider (#321)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: nicklasl

openfeature-provider/go/README.md

@@ -395,6 +395,59 @@ With `nil` default, you get the resolved value as-is using natural Go types (num
 - Negative numbers cannot convert to unsigned integers
 - Null values in the flag use the corresponding default value for that field
 
+## Direct Resolve API
+
+In addition to the standard OpenFeature evaluation methods, the provider exposes a lower-level `Resolve` / `ApplyFlags` API for use cases that need more control — for example, resolving multiple flags in a single call or deferring exposure logging.
+
+### Resolve with immediate apply
+
+```go
+provider, _ := confidence.NewProvider(ctx, confidence.ProviderConfig{
+    ClientSecret: "your-client-secret",
+})
+openfeature.SetProviderAndWait(provider)
+
+evalCtx := openfeature.FlattenedContext{
+    "targeting_key": "user-123",
+    "country":       "US",
+}
+
+// Resolve one or more flags at once with apply=true to record exposures immediately.
+// Pass an empty slice to resolve all flags available to the client.
+resp, err := provider.Resolve(ctx, evalCtx, []string{"flag-a", "flag-b"}, true)
+if err != nil {
+    log.Fatal(err)
+}
+for _, f := range resp.ResolvedFlags {
+    log.Printf("%s → %s", f.Flag, f.Variant)
+}
+```
+
+### Deferred apply
+
+When `apply` is `false`, the response contains a `ResolveToken`. Pass it to `ApplyFlags` later to record exposure events — useful when you resolve flags on the server but only want to log exposure once the client actually renders the experience.
+
+```go
+// 1. Resolve without applying
+resp, err := provider.Resolve(ctx, evalCtx, []string{"checkout-flow"}, false)
+if err != nil {
+    log.Fatal(err)
+}
+
+// 2. … later, after the user has been exposed …
+err = provider.ApplyFlags(&resolver.ApplyFlagsRequest{
+    Flags: []*resolver.AppliedFlag{
+        {Flag: "flags/checkout-flow", ApplyTime: timestamppb.Now()},
+    },
+    ClientSecret: "your-client-secret",
+    ResolveToken: resp.ResolveToken,
+    SendTime:     timestamppb.Now(),
+})
+if err != nil {
+    log.Printf("apply failed: %v", err)
+}
+```
+
 ## Logging
 
 The provider uses `log/slog` for structured logging. By default, logs at `Info` level and above are written to `stderr`.

openfeature-provider/go/confidence/internal/local_resolver/local_resolver.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 
+	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolver"
 	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/wasm"
 )
 
@@ -19,6 +20,7 @@ type LocalResolverFactory interface {
 type LocalResolver interface {
 	SetResolverState(*wasm.SetResolverStateRequest) error
 	ResolveProcess(*wasm.ResolveProcessRequest) (*wasm.ResolveProcessResponse, error)
+	ApplyFlags(*resolver.ApplyFlagsRequest) error
 	FlushAllLogs() error
 	FlushAssignLogs() error
 	Close(context.Context) error

openfeature-provider/go/confidence/internal/local_resolver/pool.go

@@ -8,6 +8,7 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolver"
 	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/wasm"
 )
 
@@ -75,6 +76,18 @@ func (s *PooledResolver) ResolveProcess(request *wasm.ResolveProcessRequest) (*w
 	return slot.lr.ResolveProcess(request)
 }
 
+// ApplyFlags implements LocalResolver.
+func (s *PooledResolver) ApplyFlags(request *resolver.ApplyFlagsRequest) error {
+	n := uint64(len(s.slots))
+	idx := s.rr.Add(1)
+	for !s.slots[idx%n].rw.TryRLock() {
+		idx = s.rr.Add(1)
+	}
+	slot := &s.slots[idx%n]
+	defer slot.rw.RUnlock()
+	return slot.lr.ApplyFlags(request)
+}
+
 // SetResolverState implements LocalResolver.
 func (s *PooledResolver) SetResolverState(request *wasm.SetResolverStateRequest) error {
 	return s.maintenance(func(lr LocalResolver) error {

openfeature-provider/go/confidence/internal/local_resolver/recover.go

@@ -6,6 +6,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolver"
 	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/wasm"
 )
 
@@ -96,6 +97,13 @@ func (r *RecoveringResolver) SetResolverState(request *wasm.SetResolverStateRequ
 	return
 }
 
+func (r *RecoveringResolver) ApplyFlags(request *resolver.ApplyFlagsRequest) (err error) {
+	r.withRecover("ApplyFlags", &err, func(lr LocalResolver) {
+		err = lr.ApplyFlags(request)
+	})
+	return
+}
+
 func (r *RecoveringResolver) ResolveProcess(request *wasm.ResolveProcessRequest) (resp *wasm.ResolveProcessResponse, err error) {
 	r.withRecover("ResolveProcess", &err, func(lr LocalResolver) {
 		resp, err = lr.ResolveProcess(request)

openfeature-provider/go/confidence/internal/local_resolver/wasm.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/wasm"
 
+	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolver"
 	resolverv1 "github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolverinternal"
 	"github.com/tetratelabs/wazero"
 	"github.com/tetratelabs/wazero/api"
@@ -49,6 +50,10 @@ func (r *WasmResolver) ResolveProcess(request *wasm.ResolveProcessRequest) (*was
 	return resp, err
 }
 
+func (r *WasmResolver) ApplyFlags(request *resolver.ApplyFlagsRequest) error {
+	return r.call("wasm_msg_guest_apply_flags", request, nil)
+}
+
 func (r *WasmResolver) FlushAllLogs() error {
 	resp := &resolverv1.WriteFlagLogsRequest{}
 	err := r.call("wasm_msg_guest_bounded_flush_logs", nil, resp)

openfeature-provider/go/confidence/internal/testutil/helpers.go

@@ -428,6 +428,7 @@ func (m *MockedLocalResolver) ResolveProcess(*wasm.ResolveProcessRequest) (*wasm
 	return m.Response, m.Err
 }
 func (m MockedLocalResolver) SetResolverState(*wasm.SetResolverStateRequest) error { return nil }
+func (m MockedLocalResolver) ApplyFlags(*resolver.ApplyFlagsRequest) error         { return nil }
 
 func MustJSONToProto(jsonString string) *structpb.Value {
 	var v structpb.Value

openfeature-provider/go/confidence/materialization.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	lr "github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/local_resolver"
+	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolver"
 	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/wasm"
 )
 
@@ -168,6 +169,10 @@ func readResultsToMaterializationRecords(results []ReadResult) []*wasm.Materiali
 	return records
 }
 
+func (m *materializationSupportedResolver) ApplyFlags(request *resolver.ApplyFlagsRequest) error {
+	return m.current.ApplyFlags(request)
+}
+
 func (m *materializationSupportedResolver) FlushAllLogs() (err error) {
 	return m.current.FlushAllLogs()
 }

openfeature-provider/go/confidence/provider.go

@@ -168,48 +168,24 @@ func (p *LocalResolverProvider) ObjectEvaluation(
 	return evaluate(p, ctx, flag, defaultValue, evalCtx)
 }
 
-// generic evaluation not a member since members can't be generic
-func evaluate[T any](
-	p *LocalResolverProvider,
-	ctx context.Context,
-	flag string,
-	defaultValue T,
+// resolveFlags is the shared resolve implementation used by both the OpenFeature
+// evaluate methods and the direct Resolve API. It converts the evaluation context,
+// builds the protobuf request, calls the WASM resolver, and extracts the response.
+func (p *LocalResolverProvider) resolveFlags(
 	evalCtx openfeature.FlattenedContext,
-) openfeature.GenericResolutionDetail[T] {
-	// TODO this needs better proper handling, thread safety etc.
-	if p.resolver == nil {
-		return openfeature.GenericResolutionDetail[T]{
-			Value: defaultValue,
-			ProviderResolutionDetail: openfeature.ProviderResolutionDetail{
-				Reason:          openfeature.ErrorReason,
-				ResolutionError: openfeature.NewProviderNotReadyResolutionError("provider not initialized"),
-			},
-		}
-	}
-	// Parse flag path (supports "flag.path.to.value" syntax)
-	flagName, path := parseFlagPath(flag)
-
-	// Process targeting key (convert "targetingKey" to "targeting_key")
+	flagNames []string,
+	apply bool,
+) (*resolver.ResolveFlagsResponse, error) {
 	processedCtx := processTargetingKey(evalCtx)
 
-	// Convert evaluation context to protobuf Struct
 	protoCtx, err := flattenedContextToProto(processedCtx)
 	if err != nil {
-		p.logger.Error("Failed to convert evaluation context to proto", "error", err)
-		return openfeature.GenericResolutionDetail[T]{
-			Value: defaultValue,
-			ProviderResolutionDetail: openfeature.ProviderResolutionDetail{
-				Reason:          openfeature.ErrorReason,
-				ResolutionError: openfeature.NewGeneralResolutionError(fmt.Sprintf("failed to convert context: %v", err)),
-			},
-		}
+		return nil, fmt.Errorf("failed to convert context: %w", err)
 	}
 
-	// Build resolve request
-	requestFlagName := "flags/" + flagName
 	request := &resolver.ResolveFlagsRequest{
-		Flags:             []string{requestFlagName},
-		Apply:             true,
+		Flags:             flagNames,
+		Apply:             apply,
 		ClientSecret:      p.clientSecret,
 		EvaluationContext: protoCtx,
 		Sdk: &resolvertypes.Sdk{
@@ -220,10 +196,6 @@ func evaluate[T any](
 		},
 	}
 
-	// Create ResolveProcess request without materialization support.
-	// Flags that require materializations will error gracefully.
-	// When materialization support is enabled, the materializationSupportedResolver
-	// wrapper overrides this with DeferredMaterializations and handles suspend/resume.
 	processRequest := &wasm.ResolveProcessRequest{
 		Resolve: &wasm.ResolveProcessRequest_WithoutMaterializations{
 			WithoutMaterializations: request,
@@ -232,37 +204,48 @@ func evaluate[T any](
 
 	processResponse, err := p.resolver.ResolveProcess(processRequest)
 	if err != nil {
-		p.logger.Error("Failed to resolve flag", "flag", flagName, "error", err)
-		return openfeature.GenericResolutionDetail[T]{
-			Value: defaultValue,
-			ProviderResolutionDetail: openfeature.ProviderResolutionDetail{
-				Reason:          openfeature.ErrorReason,
-				ResolutionError: openfeature.NewGeneralResolutionError(fmt.Sprintf("resolve failed: %v", err)),
-			},
-		}
+		return nil, fmt.Errorf("resolve failed: %w", err)
 	}
 
-	// Extract the actual resolve response
-	var response *resolver.ResolveFlagsResponse
 	switch result := processResponse.Result.(type) {
 	case *wasm.ResolveProcessResponse_Resolved_:
-		response = result.Resolved.Response
+		return result.Resolved.Response, nil
 	case *wasm.ResolveProcessResponse_Suspended_:
-		p.logger.Error("Unexpected suspended response for flag", "flag", flagName)
+		return nil, fmt.Errorf("unexpected suspended response")
+	default:
+		return nil, fmt.Errorf("unexpected resolve result type")
+	}
+}
+
+// generic evaluation not a member since members can't be generic
+func evaluate[T any](
+	p *LocalResolverProvider,
+	ctx context.Context,
+	flag string,
+	defaultValue T,
+	evalCtx openfeature.FlattenedContext,
+) openfeature.GenericResolutionDetail[T] {
+	if p.resolver == nil {
 		return openfeature.GenericResolutionDetail[T]{
 			Value: defaultValue,
 			ProviderResolutionDetail: openfeature.ProviderResolutionDetail{
 				Reason:          openfeature.ErrorReason,
-				ResolutionError: openfeature.NewGeneralResolutionError("unexpected suspended response"),
+				ResolutionError: openfeature.NewProviderNotReadyResolutionError("provider not initialized"),
 			},
 		}
-	default:
-		p.logger.Error("Unexpected resolve result type for flag", "flag", flagName)
+	}
+
+	flagName, path := parseFlagPath(flag)
+	requestFlagName := "flags/" + flagName
+
+	response, err := p.resolveFlags(evalCtx, []string{requestFlagName}, true)
+	if err != nil {
+		p.logger.Error("Failed to resolve flag", "flag", flagName, "error", err)
 		return openfeature.GenericResolutionDetail[T]{
 			Value: defaultValue,
 			ProviderResolutionDetail: openfeature.ProviderResolutionDetail{
 				Reason:          openfeature.ErrorReason,
-				ResolutionError: openfeature.NewGeneralResolutionError("unexpected resolve result"),
+				ResolutionError: openfeature.NewGeneralResolutionError(err.Error()),
 			},
 		}
 	}
@@ -338,6 +321,48 @@ func evaluate[T any](
 	}
 }
 
+// Resolve resolves multiple flags for the given context. If flagNames is empty,
+// all flags available to the client are resolved. When apply is true, exposure
+// events are recorded immediately. When apply is false, the response contains a
+// resolve_token that must be passed to ApplyFlags later to record exposures.
+//
+// Returns an error if the provider has not been initialized (Init not called),
+// the evaluation context cannot be converted, or the WASM resolver fails.
+// On success the returned ResolveFlagsResponse contains the resolved flag
+// values and, when apply is false, the resolve_token for deferred application.
+func (p *LocalResolverProvider) Resolve(
+	ctx context.Context,
+	evalCtx openfeature.FlattenedContext,
+	flagNames []string,
+	apply bool,
+) (*resolver.ResolveFlagsResponse, error) {
+	if p.resolver == nil {
+		return nil, fmt.Errorf("provider not initialized")
+	}
+
+	requestFlags := make([]string, len(flagNames))
+	for i, name := range flagNames {
+		requestFlags[i] = "flags/" + name
+	}
+
+	return p.resolveFlags(evalCtx, requestFlags, apply)
+}
+
+// ApplyFlags records exposure events for flags previously resolved with
+// apply=false. The request must contain the resolve_token from the original
+// resolve response.
+//
+// Returns an error if the provider has not been initialized or the WASM
+// resolver fails to process the apply request.
+func (p *LocalResolverProvider) ApplyFlags(
+	request *resolver.ApplyFlagsRequest,
+) error {
+	if p.resolver == nil {
+		return fmt.Errorf("provider not initialized")
+	}
+	return p.resolver.ApplyFlags(request)
+}
+
 // Hooks returns provider hooks (none for this implementation)
 func (p *LocalResolverProvider) Hooks() []openfeature.Hook {
 	return []openfeature.Hook{}

openfeature-provider/go/confidence/provider_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/open-feature/go-sdk/openfeature"
 	lr "github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/local_resolver"
+	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/resolver"
 	"github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/proto/wasm"
 	tu "github.com/spotify/confidence-resolver/openfeature-provider/go/confidence/internal/testutil"
 	"google.golang.org/protobuf/types/known/structpb"
@@ -498,6 +499,10 @@ func (m *mockResolverAPIForInit) FlushAssignLogs() error {
 	return nil
 }
 
+func (m *mockResolverAPIForInit) ApplyFlags(request *resolver.ApplyFlagsRequest) error {
+	return nil
+}
+
 // TestLocalResolverProvider_Init_NilStateProvider verifies Init fails when stateProvider is nil
 func TestLocalResolverProvider_Init_NilStateProvider(t *testing.T) {
 	provider := NewLocalResolverProvider(