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)))
 		}

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/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),
+			MaxCompletionTokens: 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)
+	}
+}

core/providers/test_helpers.go

@@ -0,0 +1,40 @@
+package providers
+
+import (
+	"context"
+
+	"github.com/maximhq/bifrost/core/schemas"
+)
+
+// newTestLogger creates a simple test logger
+func newTestLogger() schemas.Logger {
+	return &testLogger{}
+}
+
+type testLogger struct{}
+
+func (l *testLogger) Debug(msg string, args ...interface{})                  {}
+func (l *testLogger) Info(msg string, args ...interface{})                   {}
+func (l *testLogger) Warn(msg string, args ...interface{})                   {}
+func (l *testLogger) Error(msg string, args ...interface{})                  {}
+func (l *testLogger) Fatal(msg string, args ...interface{})                  {}
+func (l *testLogger) SetLevel(level schemas.LogLevel)                        {}
+func (l *testLogger) SetOutputType(outputType schemas.LoggerOutputType)      {}
+
+// Helper functions for tests
+func stringPtr(s string) *string {
+	return &s
+}
+
+func float64Ptr(f float64) *float64 {
+	return &f
+}
+
+func intPtr(i int) *int {
+	return &i
+}
+
+// mockPostHookRunner is a mock implementation of PostHookRunner for testing
+func mockPostHookRunner(ctx *context.Context, result *schemas.BifrostResponse, err *schemas.BifrostError) (*schemas.BifrostResponse, *schemas.BifrostError) {
+	return result, err
+}

core/schemas/bifrost.go

@@ -232,6 +232,8 @@ func (r *BifrostResponse) GetExtraFields() *BifrostResponseExtraFields {
 		return &r.ResponsesResponse.ExtraFields
 	case r.ResponsesStreamResponse != nil:
 		return &r.ResponsesStreamResponse.ExtraFields
+	case r.EmbeddingResponse != nil:
+		return &r.EmbeddingResponse.ExtraFields
 	case r.SpeechResponse != nil:
 		return &r.SpeechResponse.ExtraFields
 	case r.SpeechStreamResponse != nil:

core/version

@@ -1 +1 @@
-1.2.12
+1.2.13