Don't pass unused context

dgageot · dgageot · commit e3eb7133c93c · 2026-02-13T17:56:13.000+01:00
Signed-off-by: David Gageot &lt;david.gageot@docker.com&gt;
diff --git a/pkg/config/examples_test.go b/pkg/config/examples_test.go
@@ -70,7 +70,7 @@ func TestParseExamples(t *testing.T) {
 					continue
 				}
 
-				model, err := modelsStore.GetModel(t.Context(), model.Provider+"/"+model.Model)
+				model, err := modelsStore.GetModel(model.Provider + "/" + model.Model)
 				require.NoError(t, err)
 				require.NotNil(t, model)
 			}
diff --git a/pkg/config/model_alias.go b/pkg/config/model_alias.go
@@ -1,7 +1,6 @@
 package config
 
 import (
-	"context"
 	"log/slog"
 	"strings"
 
@@ -17,7 +16,7 @@ import (
 // either set directly on the model or inherited from a custom provider definition.
 // This is necessary because external providers (like Azure Foundry) may use the alias
 // names directly as deployment names rather than the pinned version names.
-func ResolveModelAliases(ctx context.Context, cfg *latest.Config, store *modelsdev.Store) {
+func ResolveModelAliases(cfg *latest.Config, store *modelsdev.Store) {
 	// Resolve model aliases in the models section
 	for name, modelCfg := range cfg.Models {
 		// Skip alias resolution for models with custom base_url (direct or via provider)
@@ -28,15 +27,15 @@ func ResolveModelAliases(ctx context.Context, cfg *latest.Config, store *modelsd
 			continue
 		}
 
-		if resolved := store.ResolveModelAlias(ctx, modelCfg.Provider, modelCfg.Model); resolved != modelCfg.Model {
+		if resolved := store.ResolveModelAlias(modelCfg.Provider, modelCfg.Model); resolved != modelCfg.Model {
 			modelCfg.Model = resolved
 			cfg.Models[name] = modelCfg
 		}
 
 		// Resolve model aliases in routing rules
 		for i, rule := range modelCfg.Routing {
 			if provider, model, ok := strings.Cut(rule.Model, "/"); ok {
-				if resolved := store.ResolveModelAlias(ctx, provider, model); resolved != model {
+				if resolved := store.ResolveModelAlias(provider, model); resolved != model {
 					modelCfg.Routing[i].Model = provider + "/" + resolved
 				}
 			}
@@ -53,7 +52,7 @@ func ResolveModelAliases(ctx context.Context, cfg *latest.Config, store *modelsd
 		var resolvedModels []string
 		for modelRef := range strings.SplitSeq(agent.Model, ",") {
 			if provider, model, ok := strings.Cut(modelRef, "/"); ok {
-				if resolved := store.ResolveModelAlias(ctx, provider, model); resolved != model {
+				if resolved := store.ResolveModelAlias(provider, model); resolved != model {
 					resolvedModels = append(resolvedModels, provider+"/"+resolved)
 					continue
 				}
diff --git a/pkg/config/model_alias_test.go b/pkg/config/model_alias_test.go
@@ -28,8 +28,6 @@ func TestResolveModelAliases(t *testing.T) {
 
 	store := modelsdev.NewDatabaseStore(mockData)
 
-	ctx := t.Context()
-
 	tests := []struct {
 		name     string
 		cfg      *latest.Config
@@ -239,7 +237,7 @@ func TestResolveModelAliases(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			ResolveModelAliases(ctx, tt.cfg, store)
+			ResolveModelAliases(tt.cfg, store)
 			assert.Equal(t, tt.expected, tt.cfg)
 		})
 	}
diff --git a/pkg/model/provider/bedrock/client.go b/pkg/model/provider/bedrock/client.go
@@ -112,7 +112,7 @@ func NewClient(ctx context.Context, cfg *latest.ModelConfig, env environment.Pro
 
 	// Detect prompt caching capability at init time for efficiency.
 	// Uses models.dev cache pricing as proxy for capability detection.
-	cachingSupported := detectCachingSupport(ctx, cfg.Model)
+	cachingSupported := detectCachingSupport(cfg.Model)
 
 	slog.Debug("Bedrock client created successfully",
 		"model", cfg.Model,
@@ -133,15 +133,15 @@ func NewClient(ctx context.Context, cfg *latest.ModelConfig, env environment.Pro
 // detectCachingSupport checks if a model supports prompt caching using models.dev data.
 // Models with non-zero CacheRead/CacheWrite costs support prompt caching.
 // Returns false on lookup failure (safe default for unsupported models).
-func detectCachingSupport(ctx context.Context, model string) bool {
+func detectCachingSupport(model string) bool {
 	store, err := modelsdev.NewStore()
 	if err != nil {
 		slog.Debug("Bedrock models store unavailable, prompt caching disabled", "error", err)
 		return false
 	}
 
 	modelID := "amazon-bedrock/" + model
-	m, err := store.GetModel(ctx, modelID)
+	m, err := store.GetModel(modelID)
 	if err != nil {
 		slog.Debug("Bedrock prompt caching disabled: model not found in models.dev",
 			"model_id", modelID, "error", err)
diff --git a/pkg/model/provider/bedrock/client_test.go b/pkg/model/provider/bedrock/client_test.go
@@ -1249,23 +1249,23 @@ func TestDetectCachingSupport_SupportedModel(t *testing.T) {
 	t.Parallel()
 
 	// Uses real models.dev lookup to verify Claude models support caching
-	supported := detectCachingSupport(t.Context(), "anthropic.claude-3-5-sonnet-20241022-v2:0")
+	supported := detectCachingSupport("anthropic.claude-3-5-sonnet-20241022-v2:0")
 	assert.True(t, supported)
 }
 
 func TestDetectCachingSupport_UnsupportedModel(t *testing.T) {
 	t.Parallel()
 
 	// Llama doesn't have cache pricing in models.dev
-	supported := detectCachingSupport(t.Context(), "meta.llama3-8b-instruct-v1:0")
+	supported := detectCachingSupport("meta.llama3-8b-instruct-v1:0")
 	assert.False(t, supported)
 }
 
 func TestDetectCachingSupport_UnknownModel(t *testing.T) {
 	t.Parallel()
 
 	// Unknown model should gracefully return false, not panic
-	supported := detectCachingSupport(t.Context(), "nonexistent.model.that.does.not.exist:v1")
+	supported := detectCachingSupport("nonexistent.model.that.does.not.exist:v1")
 	assert.False(t, supported)
 }
 
diff --git a/pkg/modelsdev/store.go b/pkg/modelsdev/store.go
@@ -71,13 +71,13 @@ func NewDatabaseStore(db *Database) *Store {
 }
 
 // GetDatabase returns the models.dev database, fetching from cache or API as needed.
-func (s *Store) GetDatabase(ctx context.Context) (*Database, error) {
+func (s *Store) GetDatabase() (*Database, error) {
 	return s.db()
 }
 
 // GetProvider returns a specific provider by ID.
-func (s *Store) GetProvider(ctx context.Context, providerID string) (*Provider, error) {
-	db, err := s.GetDatabase(ctx)
+func (s *Store) GetProvider(providerID string) (*Provider, error) {
+	db, err := s.GetDatabase()
 	if err != nil {
 		return nil, err
 	}
@@ -91,15 +91,15 @@ func (s *Store) GetProvider(ctx context.Context, providerID string) (*Provider,
 }
 
 // GetModel returns a specific model by provider ID and model ID.
-func (s *Store) GetModel(ctx context.Context, id string) (*Model, error) {
+func (s *Store) GetModel(id string) (*Model, error) {
 	parts := strings.SplitN(id, "/", 2)
 	if len(parts) != 2 {
 		return nil, fmt.Errorf("invalid model ID: %q", id)
 	}
 	providerID := parts[0]
 	modelID := parts[1]
 
-	provider, err := s.GetProvider(ctx, providerID)
+	provider, err := s.GetProvider(providerID)
 	if err != nil {
 		return nil, err
 	}
@@ -236,7 +236,7 @@ var datePattern = regexp.MustCompile(`-\d{4}-?\d{2}-?\d{2}$`)
 // For example, ("anthropic", "claude-sonnet-4-5") might resolve to "claude-sonnet-4-5-20250929".
 // If the model is not an alias (already pinned or unknown), the original model name is returned.
 // This method uses the models.dev database to find the corresponding pinned version.
-func (s *Store) ResolveModelAlias(ctx context.Context, providerID, modelName string) string {
+func (s *Store) ResolveModelAlias(providerID, modelName string) string {
 	if providerID == "" || modelName == "" {
 		return modelName
 	}
@@ -247,7 +247,7 @@ func (s *Store) ResolveModelAlias(ctx context.Context, providerID, modelName str
 	}
 
 	// Get the provider from the database
-	provider, err := s.GetProvider(ctx, providerID)
+	provider, err := s.GetProvider(providerID)
 	if err != nil {
 		return modelName
 	}
@@ -296,7 +296,7 @@ func isBedrockRegionPrefix(prefix string) bool {
 //   - If modelID is empty or not in "provider/model" format, returns true (fail-open)
 //   - If models.dev lookup fails for any reason, returns true (fail-open)
 //   - If lookup succeeds, returns the model's Reasoning field value
-func ModelSupportsReasoning(ctx context.Context, modelID string) bool {
+func ModelSupportsReasoning(modelID string) bool {
 	// Fail-open for empty model ID
 	if modelID == "" {
 		return true
@@ -314,7 +314,7 @@ func ModelSupportsReasoning(ctx context.Context, modelID string) bool {
 		return true
 	}
 
-	model, err := store.GetModel(ctx, modelID)
+	model, err := store.GetModel(modelID)
 	if err != nil {
 		slog.Debug("Failed to lookup model in models.dev, assuming reasoning supported to allow user choice", "model_id", modelID, "error", err)
 		return true
diff --git a/pkg/modelsdev/store_test.go b/pkg/modelsdev/store_test.go
@@ -37,8 +37,6 @@ func TestResolveModelAlias(t *testing.T) {
 
 	store := NewDatabaseStore(mockData)
 
-	ctx := t.Context()
-
 	tests := []struct {
 		name     string
 		provider string
@@ -59,7 +57,7 @@ func TestResolveModelAlias(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := store.ResolveModelAlias(ctx, tt.provider, tt.model)
+			result := store.ResolveModelAlias(tt.provider, tt.model)
 			assert.Equal(t, tt.expected, result)
 		})
 	}
diff --git a/pkg/rag/strategy/semantic_embeddings.go b/pkg/rag/strategy/semantic_embeddings.go
@@ -173,7 +173,7 @@ func NewSemanticEmbeddingsFromConfig(ctx context.Context, cfg latest.RAGStrategy
 			return
 		}
 
-		cost := calculateSemanticUsageCost(ctx, embeddingCfg.ModelsStore, chatModelID, usage)
+		cost := calculateSemanticUsageCost(embeddingCfg.ModelsStore, chatModelID, usage)
 		store.RecordUsage(totalTokens, cost)
 	}
 
@@ -501,12 +501,12 @@ func humanizeMetadataKey(key string) string {
 }
 
 // calculateSemanticUsageCost calculates cost for semantic LLM usage.
-func calculateSemanticUsageCost(ctx context.Context, modelsStore modelStore, modelID string, usage *chat.Usage) float64 {
+func calculateSemanticUsageCost(modelsStore modelStore, modelID string, usage *chat.Usage) float64 {
 	if usage == nil || modelsStore == nil || modelID == "" || strings.HasPrefix(modelID, "dmr/") {
 		return 0
 	}
 
-	model, err := modelsStore.GetModel(ctx, modelID)
+	model, err := modelsStore.GetModel(modelID)
 	if err != nil {
 		slog.Debug("Failed to get semantic model pricing from models.dev, cost will be 0",
 			"model_id", modelID,
diff --git a/pkg/rag/strategy/vector_store.go b/pkg/rag/strategy/vector_store.go
@@ -87,7 +87,7 @@ type VectorStore struct {
 }
 
 type modelStore interface {
-	GetModel(ctx context.Context, modelID string) (*modelsdev.Model, error)
+	GetModel(modelID string) (*modelsdev.Model, error)
 }
 
 // EmbeddingInputBuilder builds the string that will be sent to the embedding model
@@ -150,7 +150,7 @@ func NewVectorStore(cfg VectorStoreConfig) *VectorStore {
 	// Set usage handler to calculate cost from models.dev and emit events with CUMULATIVE totals
 	// This matches how chat completions calculate cost in runtime.go
 	cfg.Embedder.SetUsageHandler(func(tokens int64, _ float64) {
-		cost := s.calculateCost(context.Background(), tokens)
+		cost := s.calculateCost(tokens)
 		s.recordUsage(tokens, cost)
 	})
 
@@ -169,12 +169,12 @@ func (s *VectorStore) SetEmbeddingInputBuilder(builder EmbeddingInputBuilder) {
 }
 
 // calculateCost calculates embedding cost using models.dev pricing
-func (s *VectorStore) calculateCost(ctx context.Context, tokens int64) float64 {
+func (s *VectorStore) calculateCost(tokens int64) float64 {
 	if s.modelsStore == nil || strings.HasPrefix(s.modelID, "dmr/") {
 		return 0
 	}
 
-	model, err := s.modelsStore.GetModel(ctx, s.modelID)
+	model, err := s.modelsStore.GetModel(s.modelID)
 	if err != nil {
 		slog.Debug("Failed to get model pricing from models.dev, cost will be 0",
 			"model_id", s.modelID,
diff --git a/pkg/runtime/model_switcher.go b/pkg/runtime/model_switcher.go
@@ -460,7 +460,7 @@ func (r *LocalRuntime) createProviderFromConfig(ctx context.Context, cfg *latest
 	if cfg.MaxTokens != nil {
 		opts = append(opts, options.WithMaxTokens(*cfg.MaxTokens))
 	} else if r.modelsStore != nil {
-		m, err := r.modelsStore.GetModel(ctx, cfg.Provider+"/"+cfg.Model)
+		m, err := r.modelsStore.GetModel(cfg.Provider + "/" + cfg.Model)
 		if err == nil && m != nil {
 			opts = append(opts, options.WithMaxTokens(m.Limit.Output))
 		}
diff --git a/pkg/runtime/model_switcher_test.go b/pkg/runtime/model_switcher_test.go
@@ -26,7 +26,7 @@ type mockCatalogStore struct {
 	db *modelsdev.Database
 }
 
-func (m *mockCatalogStore) GetModel(_ context.Context, _ string) (*modelsdev.Model, error) {
+func (m *mockCatalogStore) GetModel(_ string) (*modelsdev.Model, error) {
 	return nil, nil
 }
 
diff --git a/pkg/runtime/runtime.go b/pkg/runtime/runtime.go
@@ -171,7 +171,7 @@ type CurrentAgentInfo struct {
 }
 
 type ModelStore interface {
-	GetModel(ctx context.Context, modelID string) (*modelsdev.Model, error)
+	GetModel(modelID string) (*modelsdev.Model, error)
 }
 
 // RAGInitializer is implemented by runtimes that support background RAG initialization.
@@ -987,7 +987,7 @@ func (r *LocalRuntime) RunStream(ctx context.Context, sess *session.Session) <-c
 			modelID := model.ID()
 			slog.Debug("Using agent", "agent", a.Name(), "model", modelID)
 			slog.Debug("Getting model definition", "model_id", modelID)
-			m, err := r.modelsStore.GetModel(ctx, modelID)
+			m, err := r.modelsStore.GetModel(modelID)
 			if err != nil {
 				slog.Debug("Failed to get model definition", "error", err)
 			}
diff --git a/pkg/runtime/runtime_test.go b/pkg/runtime/runtime_test.go
@@ -173,7 +173,7 @@ func (m *mockProviderWithError) MaxTokens() int { return 0 }
 
 type mockModelStore struct{}
 
-func (m mockModelStore) GetModel(context.Context, string) (*modelsdev.Model, error) {
+func (m mockModelStore) GetModel(string) (*modelsdev.Model, error) {
 	return nil, nil
 }
 
@@ -675,7 +675,7 @@ func (p *queueProvider) MaxTokens() int { return 0 }
 
 type mockModelStoreWithLimit struct{ limit int }
 
-func (m mockModelStoreWithLimit) GetModel(context.Context, string) (*modelsdev.Model, error) {
+func (m mockModelStoreWithLimit) GetModel(string) (*modelsdev.Model, error) {
 	return &modelsdev.Model{Limit: modelsdev.Limit{Context: m.limit}, Cost: &modelsdev.Cost{}}, nil
 }
 
diff --git a/pkg/teamloader/teamloader.go b/pkg/teamloader/teamloader.go
@@ -116,7 +116,7 @@ func LoadWithConfig(ctx context.Context, agentSource config.Source, runConfig *c
 	if err != nil {
 		slog.Debug("Failed to create modelsdev store for alias resolution", "error", err)
 	} else {
-		config.ResolveModelAliases(ctx, cfg, modelsStore)
+		config.ResolveModelAliases(cfg, modelsStore)
 	}
 
 	// Apply model overrides from CLI flags before checking required env vars
@@ -318,7 +318,7 @@ func getModelsForAgent(ctx context.Context, cfg *latest.Config, a *latest.AgentC
 			if err != nil {
 				return nil, false, err
 			}
-			m, err := modelsStore.GetModel(ctx, modelCfg.Provider+"/"+modelCfg.Model)
+			m, err := modelsStore.GetModel(modelCfg.Provider + "/" + modelCfg.Model)
 			if err == nil {
 				maxTokens = &m.Limit.Output
 			}
@@ -381,7 +381,7 @@ func getFallbackModelsForAgent(ctx context.Context, cfg *latest.Config, a *lates
 			if err != nil {
 				return nil, err
 			}
-			m, err := modelsStore.GetModel(ctx, modelCfg.Provider+"/"+modelCfg.Model)
+			m, err := modelsStore.GetModel(modelCfg.Provider + "/" + modelCfg.Model)
 			if err == nil {
 				maxTokens = &m.Limit.Output
 			}
diff --git a/pkg/tui/commands/commands.go b/pkg/tui/commands/commands.go
@@ -262,7 +262,7 @@ func BuildCommandCategories(ctx context.Context, application *app.App) []Categor
 
 	// Check if the current model supports reasoning; hide /think if not
 	currentModel := application.CurrentAgentModel()
-	if !modelsdev.ModelSupportsReasoning(ctx, currentModel) {
+	if !modelsdev.ModelSupportsReasoning(currentModel) {
 		filtered := make([]Item, 0, len(sessionCommands))
 		for _, cmd := range sessionCommands {
 			if cmd.ID != "session.think" {
diff --git a/pkg/tui/components/sidebar/sidebar.go b/pkg/tui/components/sidebar/sidebar.go
@@ -1,7 +1,6 @@
 package sidebar
 
 import (
-	"context"
 	"fmt"
 	"log/slog"
 	"maps"
@@ -253,7 +252,7 @@ func (m *model) SetAgentInfo(agentName, modelID, description string) {
 	m.currentAgent = agentName
 	m.agentModel = modelID
 	m.agentDescription = description
-	m.reasoningSupported = modelsdev.ModelSupportsReasoning(context.Background(), modelID)
+	m.reasoningSupported = modelsdev.ModelSupportsReasoning(modelID)
 
 	// Update the provider and model in availableAgents for the current agent.
 	// This is important when fallback models from different providers are used.
diff --git a/pkg/tui/handlers.go b/pkg/tui/handlers.go
@@ -330,7 +330,7 @@ func (a *appModel) handleToggleYolo() (tea.Model, tea.Cmd) {
 func (a *appModel) handleToggleThinking() (tea.Model, tea.Cmd) {
 	// Check if the current model supports reasoning
 	currentModel := a.application.CurrentAgentModel()
-	if !modelsdev.ModelSupportsReasoning(context.Background(), currentModel) {
+	if !modelsdev.ModelSupportsReasoning(currentModel) {
 		return a, notification.InfoCmd("Thinking/reasoning is not supported for the current model")
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ func TestParseExamples(t *testing.T) {`
`70`	`70`	`continue`
`71`	`71`	`}`
`72`	`72`
`73`		`- model, err := modelsStore.GetModel(t.Context(), model.Provider+"/"+model.Model)`
	`73`	`+ model, err := modelsStore.GetModel(model.Provider + "/" + model.Model)`
`74`	`74`	`require.NoError(t, err)`
`75`	`75`	`require.NotNil(t, model)`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ func NewSemanticEmbeddingsFromConfig(ctx context.Context, cfg latest.RAGStrategy`
`173`	`173`	`return`
`174`	`174`	`}`
`175`	`175`
`176`		`- cost := calculateSemanticUsageCost(ctx, embeddingCfg.ModelsStore, chatModelID, usage)`
	`176`	`+ cost := calculateSemanticUsageCost(embeddingCfg.ModelsStore, chatModelID, usage)`
`177`	`177`	`store.RecordUsage(totalTokens, cost)`
`178`	`178`	`}`
`179`	`179`
`@@ -501,12 +501,12 @@ func humanizeMetadataKey(key string) string {`
`501`	`501`	`}`
`502`	`502`
`503`	`503`	`// calculateSemanticUsageCost calculates cost for semantic LLM usage.`
`504`		`-func calculateSemanticUsageCost(ctx context.Context, modelsStore modelStore, modelID string, usage *chat.Usage) float64 {`
	`504`	`+func calculateSemanticUsageCost(modelsStore modelStore, modelID string, usage *chat.Usage) float64 {`
`505`	`505`	`if usage == nil \|\| modelsStore == nil \|\| modelID == "" \|\| strings.HasPrefix(modelID, "dmr/") {`
`506`	`506`	`return 0`
`507`	`507`	`}`
`508`	`508`
`509`		`- model, err := modelsStore.GetModel(ctx, modelID)`
	`509`	`+ model, err := modelsStore.GetModel(modelID)`
`510`	`510`	`if err != nil {`
`511`	`511`	`slog.Debug("Failed to get semantic model pricing from models.dev, cost will be 0",`
`512`	`512`	`"model_id", modelID,`
Original file line number	Diff line number	Diff line change
`@@ -460,7 +460,7 @@ func (r LocalRuntime) createProviderFromConfig(ctx context.Context, cfg latest`
`460`	`460`	`if cfg.MaxTokens != nil {`
`461`	`461`	`opts = append(opts, options.WithMaxTokens(*cfg.MaxTokens))`
`462`	`462`	`} else if r.modelsStore != nil {`
`463`		`- m, err := r.modelsStore.GetModel(ctx, cfg.Provider+"/"+cfg.Model)`
	`463`	`+ m, err := r.modelsStore.GetModel(cfg.Provider + "/" + cfg.Model)`
`464`	`464`	`if err == nil && m != nil {`
`465`	`465`	`opts = append(opts, options.WithMaxTokens(m.Limit.Output))`
`466`	`466`	`}`