fix: minor type fixes

Author: Pratham-Mishra04

core/schemas/chatcompletions.go

@@ -14,7 +14,7 @@ type ChatParameters struct {
 	LogProbs            *bool               `json:"logprobs,omitempty"`              // Number of logprobs to return
 	MaxCompletionTokens *int                `json:"max_completion_tokens,omitempty"` // Maximum number of tokens to generate
 	Metadata            *map[string]any     `json:"metadata,omitempty"`              // Metadata to be returned with the response
-	Modalities          []string           `json:"modalities,omitempty"`            // Modalities to be returned with the response
+	Modalities          []string            `json:"modalities,omitempty"`            // Modalities to be returned with the response
 	ParallelToolCalls   *bool               `json:"parallel_tool_calls,omitempty"`
 	PresencePenalty     *float64            `json:"presence_penalty,omitempty"`  // Penalizes repeated tokens
 	PromptCacheKey      *string             `json:"prompt_cache_key,omitempty"`  // Prompt cache key
@@ -24,7 +24,7 @@ type ChatParameters struct {
 	Seed                *int                `json:"seed,omitempty"`
 	ServiceTier         *string             `json:"service_tier,omitempty"`
 	StreamOptions       *ChatStreamOptions  `json:"stream_options,omitempty"`
-	Stop                []string           `json:"stop,omitempty"`
+	Stop                []string            `json:"stop,omitempty"`
 	Store               *bool               `json:"store,omitempty"`
 	Temperature         *float64            `json:"temperature,omitempty"`
 	TopLogProbs         *int                `json:"top_logprobs,omitempty"`
@@ -71,7 +71,7 @@ type ToolFunctionParameters struct {
 	Description *string                `json:"description,omitempty"` // Description of the parameters
 	Required    []string               `json:"required,omitempty"`    // Required parameter names
 	Properties  map[string]interface{} `json:"properties,omitempty"`  // Parameter properties
-	Enum        []string              `json:"enum,omitempty"`        // Enum values for the parameters
+	Enum        []string               `json:"enum,omitempty"`        // Enum values for the parameters
 }
 
 type ChatToolCustom struct {
@@ -89,7 +89,7 @@ type ChatToolCustomGrammarFormat struct {
 	Syntax     string `json:"syntax"`     // "lark" | "regex"
 }
 
-// Combined tool choices for all providers, make sure to check the provider's
+// ChatToolChoiceType  for all providers, make sure to check the provider's
 // documentation to see which tool choices are supported.
 type ChatToolChoiceType string
 
@@ -178,7 +178,7 @@ type ChatToolChoiceAllowedToolsTool struct {
 
 // MESSAGES
 
-// ModelChatMessageRole represents the role of a chat message
+// ChatMessageRole represents the role of a chat message
 type ChatMessageRole string
 
 const (
@@ -296,7 +296,7 @@ type ChatToolMessage struct {
 type ChatAssistantMessage struct {
 	Refusal     *string                          `json:"refusal,omitempty"`
 	Annotations []ChatAssistantMessageAnnotation `json:"annotations,omitempty"`
-	ToolCalls   []ChatAssistantMessageToolCall  `json:"tool_calls,omitempty"`
+	ToolCalls   []ChatAssistantMessageToolCall   `json:"tool_calls,omitempty"`
 }
 
 // ChatAssistantMessageAnnotation represents an annotation in a response.

core/schemas/providers/anthropic/chat.go

@@ -780,16 +780,12 @@ func ToAnthropicChatCompletionError(bifrostErr *schemas.BifrostError) *Anthropic
 
 	// Handle nested error fields with nil checks
 	errorStruct := AnthropicMessageErrorStruct{
-		Type:    "",
+		Type:    errorType,
 		Message: bifrostErr.Error.Message,
 	}
 
-	if bifrostErr.Error.Type != nil {
-		errorStruct.Type = *bifrostErr.Error.Type
-	}
-
 	return &AnthropicMessageError{
-		Type:  errorType,
+		Type:  "error", // always "error" for Anthropic
 		Error: errorStruct,
 	}
 }

core/schemas/providers/anthropic/responses.go

@@ -129,7 +129,7 @@ func ToAnthropicResponsesRequest(bifrostReq *schemas.BifrostResponsesRequest) *A
 			if ok {
 				anthropicReq.TopK = topK
 			}
-			if stop, ok := schemas.SafeExtractStringSlicePointer(bifrostReq.Params.ExtraParams["stop"]); ok {
+			if stop, ok := schemas.SafeExtractStringSlice(bifrostReq.Params.ExtraParams["stop"]); ok {
 				anthropicReq.StopSequences = stop
 			}
 		}
@@ -891,7 +891,7 @@ func convertBifrostMessagesToAnthropicContent(messages []schemas.ResponsesMessag
 					})
 				} else if msg.Content.ContentBlocks != nil {
 					// Convert content blocks
-						for _, block := range msg.Content.ContentBlocks {
+					for _, block := range msg.Content.ContentBlocks {
 						anthropicBlock := convertContentBlockToAnthropic(block)
 						if anthropicBlock != nil {
 							contentBlocks = append(contentBlocks, *anthropicBlock)

core/schemas/providers/bedrock/responses.go

@@ -44,7 +44,7 @@ func ToBedrockResponsesRequest(bifrostReq *schemas.BifrostResponsesRequest) (*Be
 			inferenceConfig.TopP = bifrostReq.Params.TopP
 		}
 		if bifrostReq.Params.ExtraParams != nil {
-			if stop, ok := schemas.SafeExtractStringSlicePointer(bifrostReq.Params.ExtraParams["stop"]); ok {
+			if stop, ok := schemas.SafeExtractStringSlice(bifrostReq.Params.ExtraParams["stop"]); ok {
 				inferenceConfig.StopSequences = stop
 			}
 		}

core/schemas/providers/cohere/responses.go

@@ -32,7 +32,7 @@ func ToCohereResponsesRequest(bifrostReq *schemas.BifrostResponsesRequest) *Cohe
 			if topK, ok := schemas.SafeExtractIntPointer(bifrostReq.Params.ExtraParams["top_k"]); ok {
 				cohereReq.K = topK
 			}
-			if stop, ok := schemas.SafeExtractStringSlicePointer(bifrostReq.Params.ExtraParams["stop"]); ok {
+			if stop, ok := schemas.SafeExtractStringSlice(bifrostReq.Params.ExtraParams["stop"]); ok {
 				cohereReq.StopSequences = stop
 			}
 			if frequencyPenalty, ok := schemas.SafeExtractFloat64Pointer(bifrostReq.Params.ExtraParams["frequency_penalty"]); ok {

core/schemas/utils.go

@@ -510,17 +510,6 @@ func SafeExtractBoolPointer(value interface{}) (*bool, bool) {
 	return nil, false
 }
 
-// SafeExtractStringSlicePointer safely extracts a []string value from an interface{} with type checking
-func SafeExtractStringSlicePointer(value interface{}) ([]string, bool) {
-	if value == nil {
-		return nil, false
-	}
-	if sliceVal, ok := SafeExtractStringSlice(value); ok {
-		return sliceVal, true
-	}
-	return nil, false
-}
-
 // SafeExtractFromMap safely extracts a value from a map[string]interface{} with type checking
 func SafeExtractFromMap(m map[string]interface{}, key string) (interface{}, bool) {
 	if m == nil {

framework/streaming/accumulator.go

@@ -309,7 +309,7 @@ func (a *Accumulator) cleanupOldAccumulators() {
 	a.streamAccumulators.Range(func(key, value interface{}) bool {
 		accumulator := value.(*StreamAccumulator)
 		if accumulator.Timestamp.Before(time.Now().Add(-a.ttl)) {
-			a.streamAccumulators.Delete(key)
+			a.cleanupStreamAccumulator(key.(string))			
 		}
 		count++
 		return true

framework/streaming/audio.go

@@ -33,11 +33,13 @@ func (a *Accumulator) processAccumulatedAudioStreamingChunks(requestID string, b
 	accumulator := a.getOrCreateStreamAccumulator(requestID)
 	// Lock the accumulator
 	accumulator.mu.Lock()
-	defer accumulator.mu.Unlock()
-	if isFinalChunk {		
-		// Before unlocking, we cleanup
-		defer a.cleanupStreamAccumulator(requestID)
-	}
+	defer func() {
+		accumulator.mu.Unlock()
+		if isFinalChunk {
+			// Before unlocking, we cleanup
+			defer a.cleanupStreamAccumulator(requestID)
+		}
+	}()
 	data := &AccumulatedData{
 		RequestID:      requestID,
 		Status:         "success",
@@ -78,7 +80,7 @@ func (a *Accumulator) processAccumulatedAudioStreamingChunks(requestID string, b
 				PromptTokens:     lastChunk.TokenUsage.InputTokens,
 				CompletionTokens: lastChunk.TokenUsage.OutputTokens,
 				TotalTokens:      lastChunk.TokenUsage.TotalTokens,
-			}			
+			}
 		}
 	}
 	// Update cost from final chunk if available

framework/streaming/chat.go

@@ -50,12 +50,14 @@ func (a *Accumulator) buildCompleteMessageFromChatStreamChunks(chunks []*ChatStr
 func (a *Accumulator) processAccumulatedChatStreamingChunks(requestID string, respErr *schemas.BifrostError, isFinalChunk bool) (*AccumulatedData, error) {
 	accumulator := a.getOrCreateStreamAccumulator(requestID)
 	// Lock the accumulator
-	accumulator.mu.Lock()	
-	defer accumulator.mu.Unlock()
-	if isFinalChunk {
-		// Before unlocking, we cleanup
-		defer a.cleanupStreamAccumulator(requestID)
-	}
+	accumulator.mu.Lock()
+	defer func() {
+		accumulator.mu.Unlock()
+		if isFinalChunk {
+			// Before unlocking, we cleanup
+			defer a.cleanupStreamAccumulator(requestID)
+		}
+	}()
 	// Initialize accumulated data
 	data := &AccumulatedData{
 		RequestID:      requestID,
@@ -111,11 +113,12 @@ func (a *Accumulator) processAccumulatedChatStreamingChunks(requestID string, re
 		if lastChunk.Cost != nil {
 			data.Cost = lastChunk.Cost
 		}
+		data.FinishReason = lastChunk.FinishReason
 	}
 	// Update object field from accumulator (stored once for the entire stream)
 	if accumulator.Object != "" {
 		data.Object = accumulator.Object
-	}
+	}	
 	return data, nil
 }
 

framework/streaming/transcription.go

@@ -31,11 +31,13 @@ func (a *Accumulator) processAccumulatedTranscriptionStreamingChunks(requestID s
 	accumulator := a.getOrCreateStreamAccumulator(requestID)
 	// Lock the accumulator
 	accumulator.mu.Lock()
-	defer accumulator.mu.Unlock()
-	if isFinalChunk {
-		// Before unlocking, we cleanup
-		defer a.cleanupStreamAccumulator(requestID)
-	}
+	defer func() {
+		accumulator.mu.Unlock()
+		if isFinalChunk {
+			// Before unlocking, we cleanup
+			defer a.cleanupStreamAccumulator(requestID)
+		}
+	}()
 	data := &AccumulatedData{
 		RequestID:      requestID,
 		Status:         "success",