chore: tests fixes

Author: Pratham-Mishra04

.github/workflows/scripts/release-core.sh

@@ -32,10 +32,14 @@ fi
 # Building core
 go mod download
 go build ./...
-go test ./...
 cd ..
 echo "✅ Core build validation successful"
 
+# Run core provider tests
+echo "🔧 Running core provider tests..."
+cd tests/core-providers
+go test -v ./...
+cd ../..
 
 # Capturing changelog
 CHANGELOG_BODY=$(cat core/changelog.md)

.gitignore

@@ -33,4 +33,6 @@ go.work.sum
 # Sqlite DBs
 *.db
 *.db-shm
-*.db-wal
+*.db-wal
+
+.claude

core/bifrost.go

@@ -1229,7 +1229,11 @@ func (bifrost *Bifrost) handleRequest(ctx context.Context, req *schemas.BifrostR
 	primaryResult, primaryErr := bifrost.tryRequest(ctx, req)
 
 	if primaryErr != nil {
-		bifrost.logger.Debug(fmt.Sprintf("Primary provider %s with model %s returned error: %v", provider, model, primaryErr))
+		if primaryErr.Error != nil {
+			bifrost.logger.Debug(fmt.Sprintf("Primary provider %s with model %s returned error: %s", provider, model, primaryErr.Error.Message))
+		} else {
+			bifrost.logger.Debug(fmt.Sprintf("Primary provider %s with model %s returned error: %v", provider, model, primaryErr))
+		}
 		if len(fallbacks) > 0 {
 			bifrost.logger.Debug(fmt.Sprintf("Check if we should try %d fallbacks", len(fallbacks)))
 		}
@@ -1629,7 +1633,7 @@ func (bifrost *Bifrost) requestWorker(provider schemas.Provider, config *schemas
 				time.Sleep(backoff)
 			}
 
-			bifrost.logger.Debug("attempting request for provider %s", provider.GetProviderKey())
+			bifrost.logger.Debug("attempting %s request for provider %s", req.RequestType, provider.GetProviderKey())
 
 			// Attempt the request
 			if IsStreamRequestType(req.RequestType) {
@@ -1644,7 +1648,7 @@ func (bifrost *Bifrost) requestWorker(provider schemas.Provider, config *schemas
 				}
 			}
 
-			bifrost.logger.Debug("request for provider %s completed", provider.GetProviderKey())
+			bifrost.logger.Debug("request %s for provider %s completed", req.RequestType, provider.GetProviderKey())
 
 			// Check if successful or if we should retry
 			if bifrostError == nil ||

core/changelog.md

@@ -1,6 +1,6 @@
 <!-- The pattern we follow here is to keep the changelog for the latest version -->
 <!-- Old changelogs are automatically attached to the GitHub releases -->
 
-- fix: openai specific parameters filtered for openai compatibile providers
-- fix: error response unmarshalling for gemini provider
-- BREAKING FIX: json_schema field correctly renamed to schema; ResponsesTextConfigFormatJSONSchema restructured
+- bug: fixed embedding request not being handled in `GetExtraFields()` method of `BifrostResponse`
+- fix: added latency calculation for vertex native requests
+- feat: added cached tokens and reasoning tokens to the usage metadata for chat completions

core/providers/groq.go

@@ -124,13 +124,18 @@ func (provider *GroqProvider) TextCompletionStream(ctx context.Context, postHook
 				responseChan <- response
 				continue
 			}
-			response.ToTextCompletionResponse()
-			if response.BifrostTextCompletionResponse != nil {
-				response.BifrostTextCompletionResponse.ExtraFields.RequestType = schemas.TextCompletionRequest
-				response.BifrostTextCompletionResponse.ExtraFields.Provider = provider.GetProviderKey()
-				response.BifrostTextCompletionResponse.ExtraFields.ModelRequested = request.Model
+			if response.BifrostChatResponse != nil {
+				textCompletionResponse := response.BifrostChatResponse.ToTextCompletionResponse()
+				if textCompletionResponse != nil {
+					textCompletionResponse.ExtraFields.RequestType = schemas.TextCompletionRequest
+					textCompletionResponse.ExtraFields.Provider = provider.GetProviderKey()
+					textCompletionResponse.ExtraFields.ModelRequested = request.Model
+
+					responseChan <- &schemas.BifrostStream{
+						BifrostTextCompletionResponse: textCompletionResponse,
+					}
+				}
 			}
-			responseChan <- response
 		}
 	}()
 	return responseChan, nil

core/providers/openai_test.go

@@ -0,0 +1,282 @@
+package providers
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/maximhq/bifrost/core/schemas"
+)
+
+func TestOpenAIChatCompletion(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		t.Skip("OPENAI_API_KEY not set")
+	}
+
+	provider := NewOpenAIProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.openai.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	request := &schemas.BifrostChatRequest{
+		Provider: schemas.OpenAI,
+		Model:    "gpt-3.5-turbo",
+		Input: []schemas.ChatMessage{
+			{
+				Role:    "user",
+				Content: &schemas.ChatMessageContent{ContentStr: stringPtr("Say hello in one word")},
+			},
+		},
+		Params: &schemas.ChatParameters{
+			Temperature:         float64Ptr(0.7),
+			MaxCompletionTokens: intPtr(10),
+		},
+	}
+
+	resp, err := provider.ChatCompletion(ctx, key, request)
+	if err != nil {
+		t.Fatalf("ChatCompletion failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Choices) == 0 {
+		t.Fatal("Expected at least one choice")
+	}
+	if resp.Choices[0].Message.Content == nil {
+		t.Fatal("Expected message content")
+	}
+	t.Logf("Response: %s", *resp.Choices[0].Message.Content)
+}
+
+func TestOpenAIChatCompletionWithTools(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		t.Skip("OPENAI_API_KEY not set")
+	}
+
+	provider := NewOpenAIProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.openai.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	props := map[string]interface{}{
+		"location": map[string]interface{}{
+			"type":        "string",
+			"description": "The city name",
+		},
+	}
+
+	request := &schemas.BifrostChatRequest{
+		Provider: schemas.OpenAI,
+		Model:    "gpt-3.5-turbo",
+		Input: []schemas.ChatMessage{
+			{
+				Role:    "user",
+				Content: &schemas.ChatMessageContent{ContentStr: stringPtr("What's the weather in San Francisco?")},
+			},
+		},
+		Params: &schemas.ChatParameters{
+			Temperature:         float64Ptr(0.7),
+			MaxCompletionTokens: intPtr(100),
+			Tools: []schemas.ChatTool{
+				{
+					Type: schemas.ChatToolTypeFunction,
+					Function: &schemas.ChatToolFunction{
+						Name:        "get_weather",
+						Description: stringPtr("Get the current weather"),
+						Parameters: &schemas.ToolFunctionParameters{
+							Type:       "object",
+							Properties: &props,
+							Required:   []string{"location"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	resp, err := provider.ChatCompletion(ctx, key, request)
+	if err != nil {
+		t.Fatalf("ChatCompletion with tools failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Choices) == 0 {
+		t.Fatal("Expected at least one choice")
+	}
+	t.Logf("Tool calls: %d", len(resp.Choices[0].Message.ToolCalls))
+}
+
+func TestOpenAIChatCompletionStream(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		t.Skip("OPENAI_API_KEY not set")
+	}
+
+	provider := NewOpenAIProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.openai.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	request := &schemas.BifrostChatRequest{
+		Provider: schemas.OpenAI,
+		Model:    "gpt-3.5-turbo",
+		Input: []schemas.ChatMessage{
+			{
+				Role:    "user",
+				Content: &schemas.ChatMessageContent{ContentStr: stringPtr("Count from 1 to 3")},
+			},
+		},
+		Params: &schemas.ChatParameters{
+			Temperature: float64Ptr(0.7),
+		},
+	}
+
+	streamChan, err := provider.ChatCompletionStream(ctx, mockPostHookRunner, key, request)
+	if err != nil {
+		t.Fatalf("ChatCompletionStream failed: %v", err)
+	}
+
+	count := 0
+	for chunk := range streamChan {
+		if chunk.Error != nil {
+			t.Fatalf("Stream error: %v", chunk.Error)
+		}
+		count++
+	}
+
+	if count == 0 {
+		t.Fatal("Expected at least one chunk")
+	}
+	t.Logf("Received %d chunks", count)
+}
+
+func TestOpenAITextCompletion(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		t.Skip("OPENAI_API_KEY not set")
+	}
+
+	provider := NewOpenAIProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.openai.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	request := &schemas.BifrostTextCompletionRequest{
+		Provider: schemas.OpenAI,
+		Model:    "gpt-3.5-turbo-instruct",
+		Input:    &schemas.TextCompletionInput{PromptStr: stringPtr("Say hello")},
+		Params: &schemas.TextCompletionParameters{
+			Temperature: float64Ptr(0.7),
+			MaxTokens:   intPtr(10),
+		},
+	}
+
+	resp, err := provider.TextCompletion(ctx, key, request)
+	if err != nil {
+		t.Fatalf("TextCompletion failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Choices) == 0 {
+		t.Fatal("Expected at least one choice")
+	}
+	t.Logf("Response: %s", resp.Choices[0].Text)
+}
+
+func TestOpenAIEmbedding(t *testing.T) {
+	apiKey := os.Getenv("OPENAI_API_KEY")
+	if apiKey == "" {
+		t.Skip("OPENAI_API_KEY not set")
+	}
+
+	provider := NewOpenAIProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL:                        "https://api.openai.com",
+			DefaultRequestTimeoutInSeconds: 30,
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	ctx := context.Background()
+	key := schemas.Key{Value: apiKey}
+
+	request := &schemas.BifrostEmbeddingRequest{
+		Provider: schemas.OpenAI,
+		Model:    "text-embedding-ada-002",
+		Input:    &schemas.EmbeddingInput{Texts: []string{"Hello world"}},
+	}
+
+	resp, err := provider.Embedding(ctx, key, request)
+	if err != nil {
+		t.Fatalf("Embedding failed: %v", err)
+	}
+
+	if resp == nil {
+		t.Fatal("Expected non-nil response")
+	}
+	if len(resp.Data) == 0 {
+		t.Fatal("Expected at least one embedding")
+	}
+	if resp.Data[0].Embedding.EmbeddingArray == nil || len(resp.Data[0].Embedding.EmbeddingArray) == 0 {
+		t.Fatal("Expected non-empty embedding vector")
+	}
+	t.Logf("Embedding dimension: %d", len(resp.Data[0].Embedding.EmbeddingArray))
+}
+
+func TestOpenAIGetProviderKey(t *testing.T) {
+	provider := NewOpenAIProvider(&schemas.ProviderConfig{
+		NetworkConfig: schemas.NetworkConfig{
+			BaseURL: "https://api.openai.com",
+		},
+		ConcurrencyAndBufferSize: schemas.ConcurrencyAndBufferSize{
+			Concurrency: 10,
+		},
+	}, newTestLogger())
+
+	key := provider.GetProviderKey()
+	if key != schemas.OpenAI {
+		t.Errorf("Expected provider key %s, got %s", schemas.OpenAI, key)
+	}
+}