diff --git a/bifrost.go b/bifrost.go
index 6bf7b8d64c..81588ebbe9 100644
--- a/bifrost.go
+++ b/bifrost.go
@@ -1,3 +1,6 @@
+// Package bifrost provides the core implementation of the Bifrost system.
+// Bifrost is a unified interface for interacting with various AI model providers,
+// managing concurrent requests, and handling provider-specific configurations.
 package bifrost
 
 import (
@@ -15,6 +18,7 @@ import (
 	"github.com/maximhq/bifrost/providers"
 )
 
+// RequestType represents the type of request being made to a provider.
 type RequestType string
 
 const (
@@ -22,6 +26,8 @@ const (
 	ChatCompletionRequest RequestType = "chat_completion"
 )
 
+// ChannelMessage represents a message passed through the request channel.
+// It contains the request, response and error channels, and the request type.
 type ChannelMessage struct {
 	interfaces.BifrostRequest
 	Response chan *interfaces.BifrostResponse
@@ -29,19 +35,22 @@ type ChannelMessage struct {
 	Type     RequestType
 }
 
-// Bifrost manages providers and maintains infinite open channels
+// Bifrost manages providers and maintains sepcified open channels for concurrent processing.
+// It handles request routing, provider management, and response processing.
 type Bifrost struct {
-	account             interfaces.Account
-	providers           []interfaces.Provider // list of processed providers
-	plugins             []interfaces.Plugin
+	account             interfaces.Account                                        // account interface
+	providers           []interfaces.Provider                                     // list of processed providers
+	plugins             []interfaces.Plugin                                       // list of plugins
 	requestQueues       map[interfaces.SupportedModelProvider]chan ChannelMessage // provider request queues
-	waitGroups          map[interfaces.SupportedModelProvider]*sync.WaitGroup
-	channelMessagePool  sync.Pool // Pool for ChannelMessage objects
-	responseChannelPool sync.Pool // Pool for response channels
-	errorChannelPool    sync.Pool // Pool for error channels
-	logger              interfaces.Logger
+	waitGroups          map[interfaces.SupportedModelProvider]*sync.WaitGroup     // wait groups for each provider
+	channelMessagePool  sync.Pool                                                 // Pool for ChannelMessage objects, initial pool size is set in Init
+	responseChannelPool sync.Pool                                                 // Pool for response channels, initial pool size is set in Init
+	errorChannelPool    sync.Pool                                                 // Pool for error channels, initial pool size is set in Init
+	logger              interfaces.Logger                                         // logger instance, default logger is used if not provided
 }
 
+// createProviderFromProviderKey creates a new provider instance based on the provider key.
+// It returns an error if the provider is not supported.
 func (bifrost *Bifrost) createProviderFromProviderKey(providerKey interfaces.SupportedModelProvider, config *interfaces.ProviderConfig) (interfaces.Provider, error) {
 	switch providerKey {
 	case interfaces.OpenAI:
@@ -59,6 +68,8 @@ func (bifrost *Bifrost) createProviderFromProviderKey(providerKey interfaces.Sup
 	}
 }
 
+// prepareProvider sets up a provider with its configuration, keys, and worker channels.
+// It initializes the request queue and starts worker goroutines for processing requests.
 func (bifrost *Bifrost) prepareProvider(providerKey interfaces.SupportedModelProvider, config *interfaces.ProviderConfig) error {
 	providerConfig, err := bifrost.account.GetConfigForProvider(providerKey)
 	if err != nil {
@@ -91,7 +102,10 @@ func (bifrost *Bifrost) prepareProvider(providerKey interfaces.SupportedModelPro
 	return nil
 }
 
-// Init initializes a new Bifrost instance with the given account
+// Init initializes a new Bifrost instance with the given configuration.
+// It sets up the account, plugins, object pools, and initializes providers.
+// Returns an error if initialization fails.
+// Initial Memory Allocations happens here as per the initial pool size.
 func Init(config interfaces.BifrostConfig) (*Bifrost, error) {
 	if config.Account == nil {
 		return nil, fmt.Errorf("account is required to initialize Bifrost")
@@ -155,7 +169,8 @@ func Init(config interfaces.BifrostConfig) (*Bifrost, error) {
 	return bifrost, nil
 }
 
-// getChannelMessage gets a ChannelMessage from the pool
+// getChannelMessage gets a ChannelMessage from the pool and configures it with the request.
+// It also gets response and error channels from their respective pools.
 func (bifrost *Bifrost) getChannelMessage(req interfaces.BifrostRequest, reqType RequestType) *ChannelMessage {
 	// Get channels from pool
 	responseChan := bifrost.responseChannelPool.Get().(chan *interfaces.BifrostResponse)
@@ -181,7 +196,7 @@ func (bifrost *Bifrost) getChannelMessage(req interfaces.BifrostRequest, reqType
 	return msg
 }
 
-// releaseChannelMessage returns a ChannelMessage and its channels to the pool
+// releaseChannelMessage returns a ChannelMessage and its channels to their respective pools.
 func (bifrost *Bifrost) releaseChannelMessage(msg *ChannelMessage) {
 	// Put channels back in pools
 	bifrost.responseChannelPool.Put(msg.Response)
@@ -193,6 +208,8 @@ func (bifrost *Bifrost) releaseChannelMessage(msg *ChannelMessage) {
 	bifrost.channelMessagePool.Put(msg)
 }
 
+// SelectKeyFromProviderForModel selects an appropriate API key for a given provider and model.
+// It uses weighted random selection if multiple keys are available.
 func (bifrost *Bifrost) SelectKeyFromProviderForModel(providerKey interfaces.SupportedModelProvider, model string) (string, error) {
 	keys, err := bifrost.account.GetKeysForProvider(providerKey)
 	if err != nil {
@@ -242,7 +259,7 @@ func (bifrost *Bifrost) SelectKeyFromProviderForModel(providerKey interfaces.Sup
 	return supportedKeys[0].Value, nil
 }
 
-// calculateBackoff implements exponential backoff with jitter
+// calculateBackoff implements exponential backoff with jitter for retry attempts.
 func (bifrost *Bifrost) calculateBackoff(attempt int, config *interfaces.ProviderConfig) time.Duration {
 	// Calculate an exponential backoff: initial * 2^attempt
 	backoff := config.NetworkConfig.RetryBackoffInitial * time.Duration(1<<uint(attempt))
@@ -256,6 +273,8 @@ func (bifrost *Bifrost) calculateBackoff(attempt int, config *interfaces.Provide
 	return time.Duration(jitter)
 }
 
+// processRequests handles incoming requests from the queue for a specific provider.
+// It manages retries, error handling, and response processing.
 func (bifrost *Bifrost) processRequests(provider interfaces.Provider, queue chan ChannelMessage) {
 	defer bifrost.waitGroups[provider.GetProviderKey()].Done()
 
@@ -357,6 +376,8 @@ func (bifrost *Bifrost) processRequests(provider interfaces.Provider, queue chan
 	bifrost.logger.Debug(fmt.Sprintf("Worker for provider %s exiting...", provider.GetProviderKey()))
 }
 
+// GetConfiguredProviderFromProviderKey returns the provider instance for a given provider key.
+// Uses the GetProviderKey method of the provider interface to find the provider.
 func (bifrost *Bifrost) GetConfiguredProviderFromProviderKey(key interfaces.SupportedModelProvider) (interfaces.Provider, error) {
 	for _, provider := range bifrost.providers {
 		if provider.GetProviderKey() == key {
@@ -367,6 +388,9 @@ func (bifrost *Bifrost) GetConfiguredProviderFromProviderKey(key interfaces.Supp
 	return nil, fmt.Errorf("no provider found for key: %s", key)
 }
 
+// GetProviderQueue returns the request queue for a given provider key.
+// If the queue doesn't exist, it creates one at runtime and initializes the provider,
+// given the provider config is provided in the account interface implementation.
 func (bifrost *Bifrost) GetProviderQueue(providerKey interfaces.SupportedModelProvider) (chan ChannelMessage, error) {
 	var queue chan ChannelMessage
 	var exists bool
@@ -387,6 +411,8 @@ func (bifrost *Bifrost) GetProviderQueue(providerKey interfaces.SupportedModelPr
 	return queue, nil
 }
 
+// TextCompletionRequest sends a text completion request to the specified provider.
+// It handles plugin hooks, request validation, and response processing.
 func (bifrost *Bifrost) TextCompletionRequest(providerKey interfaces.SupportedModelProvider, req *interfaces.BifrostRequest, ctx context.Context) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	if req == nil {
 		return nil, &interfaces.BifrostError{
@@ -459,6 +485,8 @@ func (bifrost *Bifrost) TextCompletionRequest(providerKey interfaces.SupportedMo
 	return result, nil
 }
 
+// ChatCompletionRequest sends a chat completion request to the specified provider.
+// It handles plugin hooks, request validation, and response processing.
 func (bifrost *Bifrost) ChatCompletionRequest(providerKey interfaces.SupportedModelProvider, req *interfaces.BifrostRequest, ctx context.Context) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	if req == nil {
 		return nil, &interfaces.BifrostError{
@@ -532,7 +560,8 @@ func (bifrost *Bifrost) ChatCompletionRequest(providerKey interfaces.SupportedMo
 	return result, nil
 }
 
-// Shutdown gracefully stops all workers when triggered
+// Shutdown gracefully stops all workers when triggered.
+// It closes all request channels and waits for workers to exit.
 func (bifrost *Bifrost) Shutdown() {
 	bifrost.logger.Info("[BIFROST] Graceful Shutdown Initiated - Closing all request channels...")
 
@@ -547,7 +576,8 @@ func (bifrost *Bifrost) Shutdown() {
 	}
 }
 
-// Cleanup handles SIGINT (Ctrl+C) to exit cleanly
+// Cleanup handles SIGINT (Ctrl+C) to exit cleanly.
+// It sets up signal handling and calls Shutdown when interrupted.
 func (bifrost *Bifrost) Cleanup() {
 	signalChan := make(chan os.Signal, 1)
 	signal.Notify(signalChan, os.Interrupt, syscall.SIGTERM)
diff --git a/interfaces/account.go b/interfaces/account.go
index 27d88d4b46..1fa4ff439e 100644
--- a/interfaces/account.go
+++ b/interfaces/account.go
@@ -1,14 +1,27 @@
+// Package interfaces defines the core interfaces and types used by the Bifrost system.
 package interfaces
 
+// Key represents an API key and its associated configuration for a provider.
+// It contains the key value, supported models, and a weight for load balancing.
 type Key struct {
-	Value  string   `json:"value"`
-	Models []string `json:"models"`
-	Weight float64  `json:"weight"`
+	Value  string   `json:"value"`  // The actual API key value
+	Models []string `json:"models"` // List of models this key can access
+	Weight float64  `json:"weight"` // Weight for load balancing between multiple keys
 }
 
-// TODO one get config method
+// Account defines the interface for managing provider accounts and their configurations.
+// It provides methods to access provider-specific settings, API keys, and configurations.
 type Account interface {
+	// GetInitiallyConfiguredProviders returns a list of providers that are configured
+	// in the account. This is used to determine which providers are available for use.
 	GetInitiallyConfiguredProviders() ([]SupportedModelProvider, error)
+
+	// GetKeysForProvider returns the API keys configured for a specific provider.
+	// The keys include their values, supported models, and weights for load balancing.
 	GetKeysForProvider(providerKey SupportedModelProvider) ([]Key, error)
+
+	// GetConfigForProvider returns the configuration for a specific provider.
+	// This includes network settings, authentication details, and other provider-specific
+	// configurations.
 	GetConfigForProvider(providerKey SupportedModelProvider) (*ProviderConfig, error)
 }
diff --git a/interfaces/bifrost.go b/interfaces/bifrost.go
index 2ba967762c..eb75f8b34e 100644
--- a/interfaces/bifrost.go
+++ b/interfaces/bifrost.go
@@ -1,5 +1,9 @@
+// Package interfaces defines the core interfaces and types used by the Bifrost system.
 package interfaces
 
+// BifrostConfig represents the configuration for initializing a Bifrost instance.
+// It contains the necessary components for setting up the system including account details,
+// plugins, logging, and initial pool size.
 type BifrostConfig struct {
 	Account         Account
 	Plugins         []Plugin
@@ -18,104 +22,114 @@ const (
 	RoleTool      ModelChatMessageRole = "tool"
 )
 
+// SupportedModelProvider represents the different AI model providers supported by Bifrost.
 type SupportedModelProvider string
 
 const (
-	OpenAI      SupportedModelProvider = "openai"
-	Azure       SupportedModelProvider = "azure"
-	HuggingFace SupportedModelProvider = "huggingface"
-	Anthropic   SupportedModelProvider = "anthropic"
-	Google      SupportedModelProvider = "google"
-	Groq        SupportedModelProvider = "groq"
-	Bedrock     SupportedModelProvider = "bedrock"
-	Maxim       SupportedModelProvider = "maxim"
-	Cohere      SupportedModelProvider = "cohere"
-	Ollama      SupportedModelProvider = "ollama"
-	Lmstudio    SupportedModelProvider = "lmstudio"
+	OpenAI    SupportedModelProvider = "openai"
+	Azure     SupportedModelProvider = "azure"
+	Anthropic SupportedModelProvider = "anthropic"
+	Bedrock   SupportedModelProvider = "bedrock"
+	Cohere    SupportedModelProvider = "cohere"
 )
 
 //* Request Structs
 
+// RequestInput represents the input for a model request, which can be either
+// a text completion or a chat completion, but either one must be provided.
 type RequestInput struct {
 	TextCompletionInput *string
 	ChatCompletionInput *[]Message
 }
 
+// BifrostRequest represents a request to be processed by Bifrost.
+// It must be provided when calling the Bifrost for text completion or chat completion.
+// It contains the model identifier, input data, and parameters for the request.
 type BifrostRequest struct {
 	Model  string
 	Input  RequestInput
 	Params *ModelParameters
 }
 
-// ModelParameters represents the parameters for model requests
+// ModelParameters represents the parameters that can be used to configure
+// your request to the model. Bifrost follows a standard set of parameters which
+// mapped to the provider's parameters.
 type ModelParameters struct {
-	ToolChoice *ToolChoice `json:"tool_choice,omitempty"`
-	Tools      *[]Tool     `json:"tools,omitempty"`
-
-	// Common model parameters
-	Temperature       *float64  `json:"temperature,omitempty"`
-	TopP              *float64  `json:"top_p,omitempty"`
-	TopK              *int      `json:"top_k,omitempty"`
-	MaxTokens         *int      `json:"max_tokens,omitempty"`
-	StopSequences     *[]string `json:"stop_sequences,omitempty"`
-	PresencePenalty   *float64  `json:"presence_penalty,omitempty"`
-	FrequencyPenalty  *float64  `json:"frequency_penalty,omitempty"`
-	ParallelToolCalls *bool     `json:"parallel_tool_calls"`
-
-	// Dynamic parameters
+	ToolChoice        *ToolChoice `json:"tool_choice,omitempty"`
+	Tools             *[]Tool     `json:"tools,omitempty"`
+	Temperature       *float64    `json:"temperature,omitempty"`       // Controls randomness in the output
+	TopP              *float64    `json:"top_p,omitempty"`             // Controls diversity via nucleus sampling
+	TopK              *int        `json:"top_k,omitempty"`             // Controls diversity via top-k sampling
+	MaxTokens         *int        `json:"max_tokens,omitempty"`        // Maximum number of tokens to generate
+	StopSequences     *[]string   `json:"stop_sequences,omitempty"`    // Sequences that stop generation
+	PresencePenalty   *float64    `json:"presence_penalty,omitempty"`  // Penalizes repeated tokens
+	FrequencyPenalty  *float64    `json:"frequency_penalty,omitempty"` // Penalizes frequent tokens
+	ParallelToolCalls *bool       `json:"parallel_tool_calls"`         // Enables parallel tool calls
+
+	// Dynamic parameters that can be provider-specific, they are directly
+	// added to the request as is.
 	ExtraParams map[string]interface{} `json:"-"`
 }
 
+// FunctionParameters represents the parameters for a function definition.
 type FunctionParameters struct {
-	Type        string                 `json:"type,"`
-	Description *string                `json:"description,omitempty"`
-	Required    []string               `json:"required"`
-	Properties  map[string]interface{} `json:"properties"`
+	Type        string                 `json:"type,"`                 // Type of the parameters
+	Description *string                `json:"description,omitempty"` // Description of the parameters
+	Required    []string               `json:"required"`              // Required parameter names
+	Properties  map[string]interface{} `json:"properties"`            // Parameter properties
 }
 
-// Function represents a function definition for tool calls
+// Function represents a function that can be called by the model.
 type Function struct {
-	Name        string             `json:"name"`
-	Description string             `json:"description"`
-	Parameters  FunctionParameters `json:"parameters"`
+	Name        string             `json:"name"`        // Name of the function
+	Description string             `json:"description"` // Description of the function
+	Parameters  FunctionParameters `json:"parameters"`  // Parameters of the function
 }
 
-// Tool represents a tool that can be used with the model
+// Tool represents a tool that can be used with the model.
 type Tool struct {
-	ID       *string  `json:"id,omitempty"`
-	Type     string   `json:"type"`
-	Function Function `json:"function"`
+	ID       *string  `json:"id,omitempty"` // Optional tool identifier
+	Type     string   `json:"type"`         // Type of the tool
+	Function Function `json:"function"`     // Function definition
 }
 
-// combined tool choices for all providers
+// Combined tool choices for all providers, make sure to check the provider's
+// documentation to see which tool choices are supported.
 type ToolChoiceType string
 
 const (
-	ToolChoiceNone     ToolChoiceType = "none"
-	ToolChoiceAuto     ToolChoiceType = "auto"
-	ToolChoiceAny      ToolChoiceType = "any"
-	ToolChoiceTool     ToolChoiceType = "tool"
+	// ToolChoiceNone means no tool will be called
+	ToolChoiceNone ToolChoiceType = "none"
+	// ToolChoiceAuto means the model can choose whether to call a tool
+	ToolChoiceAuto ToolChoiceType = "auto"
+	// ToolChoiceAny means any tool can be called
+	ToolChoiceAny ToolChoiceType = "any"
+	// ToolChoiceTool means a specific tool must be called
+	ToolChoiceTool ToolChoiceType = "tool"
+	// ToolChoiceRequired means a tool must be called
 	ToolChoiceRequired ToolChoiceType = "required"
 )
 
+// ToolChoiceFunction represents a specific function to be called.
 type ToolChoiceFunction struct {
-	Name string `json:"name"`
+	Name string `json:"name"` // Name of the function to call
 }
 
+// ToolChoice represents how a tool should be chosen for a request.
 type ToolChoice struct {
-	Type     ToolChoiceType     `json:"type"`
-	Function ToolChoiceFunction `json:"function"`
+	Type     ToolChoiceType     `json:"type"`     // Type of tool choice
+	Function ToolChoiceFunction `json:"function"` // Function to call if type is ToolChoiceTool
 }
 
+// Message represents a single message in a chat conversation.
 type Message struct {
-	//* strict check for roles
-	Role ModelChatMessageRole `json:"role"`
-	//* need to make sure either content or imagecontent is provided
-	Content      *string       `json:"content,omitempty"`
-	ImageContent *ImageContent `json:"image_content,omitempty"`
-	ToolCalls    *[]Tool       `json:"tool_calls,omitempty"`
+	Role         ModelChatMessageRole `json:"role"`
+	Content      *string              `json:"content,omitempty"`
+	ImageContent *ImageContent        `json:"image_content,omitempty"`
+	ToolCalls    *[]Tool              `json:"tool_calls,omitempty"`
 }
 
+// ImageContent represents image data in a message.
 type ImageContent struct {
 	Type      *string `json:"type"`
 	URL       string  `json:"url"`
@@ -125,6 +139,19 @@ type ImageContent struct {
 
 //* Response Structs
 
+// BifrostResponse represents the complete result from any bifrost request.
+type BifrostResponse struct {
+	ID                string                     `json:"id"`
+	Object            string                     `json:"object"` // text.completion or chat.completion
+	Choices           []BifrostResponseChoice    `json:"choices"`
+	Model             string                     `json:"model"`
+	Created           int                        `json:"created"` // The Unix timestamp (in seconds).
+	ServiceTier       *string                    `json:"service_tier,omitempty"`
+	SystemFingerprint *string                    `json:"system_fingerprint,omitempty"`
+	Usage             LLMUsage                   `json:"usage"`
+	ExtraFields       BifrostResponseExtraFields `json:"extra_fields"`
+}
+
 // LLMUsage represents token usage information
 type LLMUsage struct {
 	PromptTokens            int                      `json:"prompt_tokens"`
@@ -134,11 +161,15 @@ type LLMUsage struct {
 	CompletionTokensDetails *CompletionTokensDetails `json:"completion_tokens_details,omitempty"`
 }
 
+// TokenDetails provides detailed information about token usage.
+// It is not provided by all model providers.
 type TokenDetails struct {
 	CachedTokens int `json:"cached_tokens,omitempty"`
 	AudioTokens  int `json:"audio_tokens,omitempty"`
 }
 
+// CompletionTokensDetails provides detailed information about completion token usage.
+// It is not provided by all model providers.
 type CompletionTokensDetails struct {
 	ReasoningTokens          int `json:"reasoning_tokens,omitempty"`
 	AudioTokens              int `json:"audio_tokens,omitempty"`
@@ -146,6 +177,7 @@ type CompletionTokensDetails struct {
 	RejectedPredictionTokens int `json:"rejected_prediction_tokens,omitempty"`
 }
 
+// BilledLLMUsage represents the billing information for token usage.
 type BilledLLMUsage struct {
 	PromptTokens     *float64 `json:"prompt_tokens,omitempty"`
 	CompletionTokens *float64 `json:"completion_tokens,omitempty"`
@@ -153,12 +185,14 @@ type BilledLLMUsage struct {
 	Classifications  *float64 `json:"classifications,omitempty"`
 }
 
+// LogProb represents the log probability of a token.
 type LogProb struct {
 	Bytes   []int   `json:"bytes,omitempty"`
 	LogProb float64 `json:"logprob"`
 	Token   string  `json:"token"`
 }
 
+// ContentLogProb represents log probability information for content.
 type ContentLogProb struct {
 	Bytes       []int     `json:"bytes"`
 	LogProb     float64   `json:"logprob"`
@@ -166,6 +200,7 @@ type ContentLogProb struct {
 	TopLogProbs []LogProb `json:"top_logprobs"`
 }
 
+// TextCompletionLogProb represents log probability information for text completion.
 type TextCompletionLogProb struct {
 	TextOffset    []int                `json:"text_offset"`
 	TokenLogProbs []float64            `json:"token_logprobs"`
@@ -173,12 +208,14 @@ type TextCompletionLogProb struct {
 	TopLogProbs   []map[string]float64 `json:"top_logprobs"`
 }
 
+// LogProbs represents the log probabilities for different aspects of a response.
 type LogProbs struct {
 	Content []ContentLogProb      `json:"content,omitempty"`
 	Refusal []LogProb             `json:"refusal,omitempty"`
 	Text    TextCompletionLogProb `json:"text,omitempty"`
 }
 
+// FunctionCall represents a call to a function.
 type FunctionCall struct {
 	Name      *string `json:"name"`
 	Arguments string  `json:"arguments"` // stringified json as retured by OpenAI, might not be a valid JSON always
@@ -191,6 +228,7 @@ type ToolCall struct {
 	Function FunctionCall `json:"function"`
 }
 
+// Citation represents a citation in a response.
 type Citation struct {
 	StartIndex int          `json:"start_index"`
 	EndIndex   int          `json:"end_index"`
@@ -200,6 +238,7 @@ type Citation struct {
 	Type       *string      `json:"type,omitempty"`
 }
 
+// Annotation represents an annotation in a response.
 type Annotation struct {
 	Type     string   `json:"type"`
 	Citation Citation `json:"url_citation"`
@@ -223,6 +262,7 @@ type BifrostResponseChoice struct {
 	LogProbs     *LogProbs                    `json:"log_probs,omitempty"`
 }
 
+// BifrostResponseExtraFields contains additional fields in a response.
 type BifrostResponseExtraFields struct {
 	Provider    SupportedModelProvider          `json:"provider"`
 	Params      ModelParameters                 `json:"model_params"`
@@ -232,19 +272,7 @@ type BifrostResponseExtraFields struct {
 	RawResponse interface{}                     `json:"raw_response"`
 }
 
-// BifrostResponse represents the complete result from a model completion
-type BifrostResponse struct {
-	ID                string                     `json:"id"`
-	Object            string                     `json:"object"` // text.completion or chat.completion
-	Choices           []BifrostResponseChoice    `json:"choices"`
-	Model             string                     `json:"model"`
-	Created           int                        `json:"created"` // The Unix timestamp (in seconds).
-	ServiceTier       *string                    `json:"service_tier,omitempty"`
-	SystemFingerprint *string                    `json:"system_fingerprint,omitempty"`
-	Usage             LLMUsage                   `json:"usage"`
-	ExtraFields       BifrostResponseExtraFields `json:"extra_fields"`
-}
-
+// BifrostError represents an error from the Bifrost system.
 type BifrostError struct {
 	EventID        *string    `json:"event_id"`
 	Type           *string    `json:"type"`
@@ -253,6 +281,7 @@ type BifrostError struct {
 	Error          ErrorField `json:"error"`
 }
 
+// ErrorField represents detailed error information.
 type ErrorField struct {
 	Type    *string     `json:"type"`
 	Code    *string     `json:"code"`
diff --git a/interfaces/logger.go b/interfaces/logger.go
index 2d97af4c1d..57d6bf25b8 100644
--- a/interfaces/logger.go
+++ b/interfaces/logger.go
@@ -1,6 +1,8 @@
+// Package interfaces defines the core interfaces and types used by the Bifrost system.
 package interfaces
 
-// LogLevel represents the severity level of a log message
+// LogLevel represents the severity level of a log message.
+// It is used to categorize and filter log messages based on their importance.
 type LogLevel string
 
 const (
@@ -10,17 +12,24 @@ const (
 	LogLevelError LogLevel = "error"
 )
 
-// Logger defines the interface for logging operations
+// Logger defines the interface for logging operations in the Bifrost system.
+// Implementations of this interface should provide methods for logging messages
+// at different severity levels.
 type Logger interface {
-	// Debug logs a debug level message
+	// Debug logs a debug-level message.
+	// This is used for detailed debugging information that is typically only needed
+	// during development or troubleshooting.
 	Debug(msg string)
 
-	// Info logs an info level message
+	// Info logs an info-level message.
+	// This is used for general informational messages about normal operation.
 	Info(msg string)
 
-	// Warn logs a warning level message
+	// Warn logs a warning-level message.
+	// This is used for potentially harmful situations that don't prevent normal operation.
 	Warn(msg string)
 
-	// Error logs an error level message
+	// Error logs an error-level message.
+	// This is used for serious problems that need attention and may prevent normal operation.
 	Error(err error)
 }
diff --git a/interfaces/meta/azure.go b/interfaces/meta/azure.go
index 700cd897ae..a1cf546622 100644
--- a/interfaces/meta/azure.go
+++ b/interfaces/meta/azure.go
@@ -1,39 +1,56 @@
+// Package meta provides provider-specific configuration structures and interfaces.
+// This file contains the Azure-specific configuration implementation.
+
 package meta
 
+// AzureMetaConfig represents the Azure-specific configuration.
+// It contains Azure-specific settings required for service access and deployment management.
 type AzureMetaConfig struct {
-	Endpoint    string            `json:"endpoint"`
-	Deployments map[string]string `json:"deployments,omitempty"`
-	APIVersion  *string           `json:"api_version,omitempty"`
+	Endpoint    string            `json:"endpoint"`              // Azure service endpoint URL
+	Deployments map[string]string `json:"deployments,omitempty"` // Mapping of model names to deployment names
+	APIVersion  *string           `json:"api_version,omitempty"` // Azure API version to use; defaults to "2024-02-01"
 }
 
+// This is not used for Azure.
 func (c *AzureMetaConfig) GetSecretAccessKey() *string {
 	return nil
 }
 
+// This is not used for Azure.
 func (c *AzureMetaConfig) GetRegion() *string {
 	return nil
 }
 
+// This is not used for Azure.
 func (c *AzureMetaConfig) GetSessionToken() *string {
 	return nil
 }
 
+// This is not used for Azure.
 func (c *AzureMetaConfig) GetARN() *string {
 	return nil
 }
 
+// This is not used for Azure.
 func (c *AzureMetaConfig) GetInferenceProfiles() map[string]string {
 	return nil
 }
 
+// GetEndpoint returns the Azure service endpoint.
+// This specifies the base URL for Azure API requests.
 func (c *AzureMetaConfig) GetEndpoint() *string {
 	return &c.Endpoint
 }
 
+// GetDeployments returns the deployment configurations.
+// This maps model names to their corresponding Azure deployment names.
+// Eg. "gpt-4o": "your-deployment-name-for-gpt-4o"
 func (c *AzureMetaConfig) GetDeployments() map[string]string {
 	return c.Deployments
 }
 
+// GetAPIVersion returns the Azure API version.
+// This specifies which version of the Azure API to use.
 func (c *AzureMetaConfig) GetAPIVersion() *string {
 	return c.APIVersion
 }
diff --git a/interfaces/meta/bedrock.go b/interfaces/meta/bedrock.go
index b9047f73bb..c33f8cdc6a 100644
--- a/interfaces/meta/bedrock.go
+++ b/interfaces/meta/bedrock.go
@@ -1,41 +1,59 @@
+// Package meta provides provider-specific configuration structures and interfaces.
+// This file contains the AWS Bedrock-specific configuration implementation.
+
 package meta
 
+// BedrockMetaConfig represents the AWS Bedrock-specific configuration.
+// It contains AWS-specific settings required for authentication and service access.
 type BedrockMetaConfig struct {
-	SecretAccessKey   *string           `json:"secret_access_key,omitempty"`
-	Region            *string           `json:"region,omitempty"`
-	SessionToken      *string           `json:"session_token,omitempty"`
-	ARN               *string           `json:"arn,omitempty"`
-	InferenceProfiles map[string]string `json:"inference_profiles,omitempty"`
+	SecretAccessKey   *string           `json:"secret_access_key,omitempty"`  // AWS secret access key for authentication
+	Region            *string           `json:"region,omitempty"`             // AWS region for service access
+	SessionToken      *string           `json:"session_token,omitempty"`      // AWS session token for temporary credentials
+	ARN               *string           `json:"arn,omitempty"`                // Amazon Resource Name for resource identification
+	InferenceProfiles map[string]string `json:"inference_profiles,omitempty"` // Mapping of model identifiers to inference profiles
 }
 
+// GetSecretAccessKey returns the AWS secret access key.
+// This is used for AWS API authentication.
 func (c *BedrockMetaConfig) GetSecretAccessKey() *string {
 	return c.SecretAccessKey
 }
 
+// GetRegion returns the AWS region.
+// This specifies which AWS region the service should be accessed from.
 func (c *BedrockMetaConfig) GetRegion() *string {
 	return c.Region
 }
 
+// GetSessionToken returns the AWS session token.
+// This is used for temporary credentials in AWS authentication.
 func (c *BedrockMetaConfig) GetSessionToken() *string {
 	return c.SessionToken
 }
 
+// GetARN returns the Amazon Resource Name.
+// This uniquely identifies AWS resources.
 func (c *BedrockMetaConfig) GetARN() *string {
 	return c.ARN
 }
 
+// GetInferenceProfiles returns the inference profiles mapping.
+// This maps model identifiers to their corresponding inference profiles.
 func (c *BedrockMetaConfig) GetInferenceProfiles() map[string]string {
 	return c.InferenceProfiles
 }
 
+// This is not used for Bedrock.
 func (c *BedrockMetaConfig) GetEndpoint() *string {
 	return nil
 }
 
+// This is not used for Bedrock.
 func (c *BedrockMetaConfig) GetDeployments() map[string]string {
 	return nil
 }
 
+// This is not used for Bedrock.
 func (c *BedrockMetaConfig) GetAPIVersion() *string {
 	return nil
 }
diff --git a/interfaces/plugin.go b/interfaces/plugin.go
index 380379f36d..9b05fc7908 100644
--- a/interfaces/plugin.go
+++ b/interfaces/plugin.go
@@ -1,8 +1,30 @@
+// Package interfaces defines the core interfaces and types used by the Bifrost system.
 package interfaces
 
 import "context"
 
+// Plugin defines the interface for Bifrost plugins.
+// Plugins can intercept and modify requests and responses at different stages
+// of the processing pipeline.
+// User can provide multiple plugins in the BifrostConfig.
+// PreHooks are executed in the order they are registered.
+// PostHooks are executed in the reverse order of PreHooks.
+
+// PreHooks and PostHooks can be used to implement custom logic, such as:
+// - Rate limiting
+// - Caching
+// - Logging
+// - Monitoring
+
 type Plugin interface {
+	// PreHook is called before a request is processed by a provider.
+	// It allows plugins to modify the request before it is sent to the provider.
+	// The context parameter can be used to maintain state across plugin calls.
+	// Returns the modified request and any error that occurred during processing.
 	PreHook(ctx *context.Context, req *BifrostRequest) (*BifrostRequest, error)
+
+	// PostHook is called after a response is received from a provider.
+	// It allows plugins to modify the response before it is returned to the caller.
+	// Returns the modified response and any error that occurred during processing.
 	PostHook(ctx *context.Context, result *BifrostResponse) (*BifrostResponse, error)
 }
diff --git a/interfaces/provider.go b/interfaces/provider.go
index 20d374ea08..54753c957e 100644
--- a/interfaces/provider.go
+++ b/interfaces/provider.go
@@ -1,8 +1,9 @@
+// Package interfaces defines the core interfaces and types used by the Bifrost system.
 package interfaces
 
 import "time"
 
-// Pre-defined errors
+// Pre-defined errors for provider operations
 var (
 	ErrProviderRequest           = "failed to make HTTP request to provider API"
 	ErrProviderResponseUnmarshal = "failed to unmarshal response from provider API"
@@ -12,60 +13,81 @@ var (
 	ErrProviderDecompress        = "failed to decompress provider's response"
 )
 
-// TODO third party providers
-
+// NetworkConfig represents the network configuration for provider connections.
 type NetworkConfig struct {
-	DefaultRequestTimeoutInSeconds int           `json:"default_request_timeout_in_seconds"`
-	MaxRetries                     int           `json:"max_retries"`
-	RetryBackoffInitial            time.Duration `json:"retry_backoff_initial"`
-	RetryBackoffMax                time.Duration `json:"retry_backoff_max"`
+	DefaultRequestTimeoutInSeconds int           `json:"default_request_timeout_in_seconds"` // Default timeout for requests
+	MaxRetries                     int           `json:"max_retries"`                        // Maximum number of retries
+	RetryBackoffInitial            time.Duration `json:"retry_backoff_initial"`              // Initial backoff duration
+	RetryBackoffMax                time.Duration `json:"retry_backoff_max"`                  // Maximum backoff duration
 }
 
+// MetaConfig defines the interface for provider-specific configuration.
+// Check /meta folder for implemented provider-specific meta configurations.
 type MetaConfig interface {
+	// GetSecretAccessKey returns the secret access key for authentication
 	GetSecretAccessKey() *string
+	// GetRegion returns the region for the provider
 	GetRegion() *string
+	// GetSessionToken returns the session token for authentication
 	GetSessionToken() *string
+	// GetARN returns the Amazon Resource Name (ARN)
 	GetARN() *string
+	// GetInferenceProfiles returns the inference profiles
 	GetInferenceProfiles() map[string]string
+	// GetEndpoint returns the provider endpoint
 	GetEndpoint() *string
+	// GetDeployments returns the deployment configurations
 	GetDeployments() map[string]string
+	// GetAPIVersion returns the API version
 	GetAPIVersion() *string
 }
 
+// ConcurrencyAndBufferSize represents configuration for concurrent operations and buffer sizes.
 type ConcurrencyAndBufferSize struct {
-	Concurrency int `json:"concurrency"`
-	BufferSize  int `json:"buffer_size"`
+	Concurrency int `json:"concurrency"` // Number of concurrent operations. Also used as the initial pool size for the provider reponses.
+	BufferSize  int `json:"buffer_size"` // Size of the buffer
 }
 
-// ProxyType defines the type of proxy to use
+// ProxyType defines the type of proxy to use for connections.
 type ProxyType string
 
 const (
-	NoProxy     ProxyType = "none"
-	HttpProxy   ProxyType = "http"
+	// NoProxy indicates no proxy should be used
+	NoProxy ProxyType = "none"
+	// HttpProxy indicates an HTTP proxy should be used
+	HttpProxy ProxyType = "http"
+	// Socks5Proxy indicates a SOCKS5 proxy should be used
 	Socks5Proxy ProxyType = "socks5"
-	EnvProxy    ProxyType = "environment"
+	// EnvProxy indicates the proxy should be read from environment variables
+	EnvProxy ProxyType = "environment"
 )
 
-// ProxyConfig holds proxy configuration
+// ProxyConfig holds the configuration for proxy settings.
 type ProxyConfig struct {
-	Type     ProxyType `json:"type"`     // Type of proxy (none, http, socks5, environment)
-	URL      string    `json:"url"`      // Proxy URL (for http and socks5)
-	Username string    `json:"username"` // Optional username for proxy authentication
-	Password string    `json:"password"` // Optional password for proxy authentication
+	Type     ProxyType `json:"type"`     // Type of proxy to use
+	URL      string    `json:"url"`      // URL of the proxy server
+	Username string    `json:"username"` // Username for proxy authentication
+	Password string    `json:"password"` // Password for proxy authentication
 }
 
+// ProviderConfig represents the complete configuration for a provider.
+// An array of ProviderConfig needs to provided in GetConfigForProvider
+// in your account interface implementation.
 type ProviderConfig struct {
-	NetworkConfig            NetworkConfig            `json:"network_config"`
-	MetaConfig               MetaConfig               `json:"meta_config,omitempty"`
-	ConcurrencyAndBufferSize ConcurrencyAndBufferSize `json:"concurrency_and_buffer_size"`
-	Logger                   Logger                   `json:"logger"`
-	ProxyConfig              *ProxyConfig             `json:"proxy_config,omitempty"`
+	NetworkConfig            NetworkConfig            `json:"network_config"`              // Network configuration
+	MetaConfig               MetaConfig               `json:"meta_config,omitempty"`       // Provider-specific configuration
+	ConcurrencyAndBufferSize ConcurrencyAndBufferSize `json:"concurrency_and_buffer_size"` // Concurrency settings
+	// Logger instance, can be provided by the user or bifrost default logger is used if not provided
+	Logger      Logger       `json:"logger"`
+	ProxyConfig *ProxyConfig `json:"proxy_config,omitempty"` // Proxy configuration
 }
 
-// Provider defines the interface for AI model providers
+// Provider defines the interface for AI model providers.
 type Provider interface {
+	// GetProviderKey returns the provider's identifier
 	GetProviderKey() SupportedModelProvider
+	// TextCompletion performs a text completion request
 	TextCompletion(model, key, text string, params *ModelParameters) (*BifrostResponse, *BifrostError)
+	// ChatCompletion performs a chat completion request
 	ChatCompletion(model, key string, messages []Message, params *ModelParameters) (*BifrostResponse, *BifrostError)
 }
diff --git a/logger.go b/logger.go
index f9002190c8..0e89072e5e 100644
--- a/logger.go
+++ b/logger.go
@@ -1,3 +1,4 @@
+// Package bifrost provides the core implementation of the Bifrost system.
 package bifrost
 
 import (
@@ -8,19 +9,24 @@ import (
 	"github.com/maximhq/bifrost/interfaces"
 )
 
-// DefaultLogger implements the Logger interface with stdout printing
+// DefaultLogger implements the Logger interface with stdout/stderr printing.
+// It provides a simple logging implementation that writes to standard output
+// and error streams with formatted timestamps and log levels.
+// It is used as the default logger if no logger is provided in the BifrostConfig.
 type DefaultLogger struct {
-	level interfaces.LogLevel
+	level interfaces.LogLevel // Current logging level
 }
 
-// NewDefaultLogger creates a new DefaultLogger instance
+// NewDefaultLogger creates a new DefaultLogger instance with the specified log level.
+// The log level determines which messages will be output based on their severity.
 func NewDefaultLogger(level interfaces.LogLevel) *DefaultLogger {
 	return &DefaultLogger{
 		level: level,
 	}
 }
 
-// formatMessage formats the log message with timestamp and level
+// formatMessage formats the log message with timestamp, level, and optional error information.
+// It creates a consistent log format: [BIFROST-TIMESTAMP] LEVEL: message (error: err)
 func (logger *DefaultLogger) formatMessage(level interfaces.LogLevel, msg string, err error) string {
 	timestamp := time.Now().Format(time.RFC3339)
 	baseMsg := fmt.Sprintf("[BIFROST-%s] %s: %s", timestamp, level, msg)
@@ -30,33 +36,38 @@ func (logger *DefaultLogger) formatMessage(level interfaces.LogLevel, msg string
 	return baseMsg
 }
 
-// Debug logs a debug level message
+// Debug logs a debug level message to stdout.
+// Messages are only output if the logger's level is set to LogLevelDebug.
 func (logger *DefaultLogger) Debug(msg string) {
 	if logger.level == interfaces.LogLevelDebug {
 		fmt.Fprintln(os.Stdout, logger.formatMessage(interfaces.LogLevelDebug, msg, nil))
 	}
 }
 
-// Info logs an info level message
+// Info logs an info level message to stdout.
+// Messages are output if the logger's level is LogLevelDebug or LogLevelInfo.
 func (logger *DefaultLogger) Info(msg string) {
 	if logger.level == interfaces.LogLevelDebug || logger.level == interfaces.LogLevelInfo {
 		fmt.Fprintln(os.Stdout, logger.formatMessage(interfaces.LogLevelInfo, msg, nil))
 	}
 }
 
-// Warn logs a warning level message
+// Warn logs a warning level message to stdout.
+// Messages are output if the logger's level is LogLevelDebug, LogLevelInfo, or LogLevelWarn.
 func (logger *DefaultLogger) Warn(msg string) {
 	if logger.level == interfaces.LogLevelDebug || logger.level == interfaces.LogLevelInfo || logger.level == interfaces.LogLevelWarn {
 		fmt.Fprintln(os.Stdout, logger.formatMessage(interfaces.LogLevelWarn, msg, nil))
 	}
 }
 
-// Error logs an error level message
+// Error logs an error level message to stderr.
+// Error messages are always output regardless of the logger's level.
 func (logger *DefaultLogger) Error(err error) {
 	fmt.Fprintln(os.Stderr, logger.formatMessage(interfaces.LogLevelError, "", err))
 }
 
-// SetLevel sets the logging level
+// SetLevel sets the logging level for the logger.
+// This determines which messages will be output based on their severity.
 func (logger *DefaultLogger) SetLevel(level interfaces.LogLevel) {
 	logger.level = level
 }
diff --git a/providers/anthropic.go b/providers/anthropic.go
index 8b9f2291e0..84d7b517d7 100644
--- a/providers/anthropic.go
+++ b/providers/anthropic.go
@@ -1,3 +1,5 @@
+// Package providers implements various LLM providers and their utility functions.
+// This file contains the Anthropic provider implementation.
 package providers
 
 import (
@@ -11,59 +13,69 @@ import (
 	"github.com/maximhq/maxim-go"
 )
 
+// AnthropicToolChoice represents the tool choice configuration for Anthropic's API.
+// It specifies how tools should be used in the completion request.
 type AnthropicToolChoice struct {
-	Type                   interfaces.ToolChoiceType `json:"type"`
-	Name                   *string                   `json:"name"`
-	DisableParallelToolUse *bool                     `json:"disable_parallel_tool_use"`
+	Type                   interfaces.ToolChoiceType `json:"type"`                      // Type of tool choice
+	Name                   *string                   `json:"name"`                      // Name of the tool to use
+	DisableParallelToolUse *bool                     `json:"disable_parallel_tool_use"` // Whether to disable parallel tool use
 }
 
+// AnthropicTextResponse represents the response structure from Anthropic's text completion API.
+// It includes the completion text, model information, and token usage statistics.
 type AnthropicTextResponse struct {
-	ID         string `json:"id"`
-	Type       string `json:"type"`
-	Completion string `json:"completion"`
-	Model      string `json:"model"`
+	ID         string `json:"id"`         // Unique identifier for the completion
+	Type       string `json:"type"`       // Type of completion
+	Completion string `json:"completion"` // Generated completion text
+	Model      string `json:"model"`      // Model used for the completion
 	Usage      struct {
-		InputTokens  int `json:"input_tokens"`
-		OutputTokens int `json:"output_tokens"`
-	} `json:"usage"`
+		InputTokens  int `json:"input_tokens"`  // Number of input tokens used
+		OutputTokens int `json:"output_tokens"` // Number of output tokens generated
+	} `json:"usage"` // Token usage statistics
 }
 
+// AnthropicChatResponse represents the response structure from Anthropic's chat completion API.
+// It includes message content, model information, and token usage statistics.
 type AnthropicChatResponse struct {
-	ID      string `json:"id"`
-	Type    string `json:"type"`
-	Role    string `json:"role"`
+	ID      string `json:"id"`   // Unique identifier for the completion
+	Type    string `json:"type"` // Type of completion
+	Role    string `json:"role"` // Role of the message sender
 	Content []struct {
-		Type     string                 `json:"type"`
-		Text     string                 `json:"text,omitempty"`
-		Thinking string                 `json:"thinking,omitempty"`
-		ID       string                 `json:"id"`
-		Name     string                 `json:"name"`
-		Input    map[string]interface{} `json:"input"`
-	} `json:"content"`
-	Model        string  `json:"model"`
-	StopReason   string  `json:"stop_reason,omitempty"`
-	StopSequence *string `json:"stop_sequence,omitempty"`
+		Type     string                 `json:"type"`               // Type of content
+		Text     string                 `json:"text,omitempty"`     // Text content
+		Thinking string                 `json:"thinking,omitempty"` // Thinking process
+		ID       string                 `json:"id"`                 // Content identifier
+		Name     string                 `json:"name"`               // Name of the content
+		Input    map[string]interface{} `json:"input"`              // Input parameters
+	} `json:"content"` // Array of content items
+	Model        string  `json:"model"`                   // Model used for the completion
+	StopReason   string  `json:"stop_reason,omitempty"`   // Reason for completion termination
+	StopSequence *string `json:"stop_sequence,omitempty"` // Sequence that caused completion to stop
 	Usage        struct {
-		InputTokens  int `json:"input_tokens"`
-		OutputTokens int `json:"output_tokens"`
-	} `json:"usage"`
+		InputTokens  int `json:"input_tokens"`  // Number of input tokens used
+		OutputTokens int `json:"output_tokens"` // Number of output tokens generated
+	} `json:"usage"` // Token usage statistics
 }
 
+// AnthropicError represents the error response structure from Anthropic's API.
+// It includes error type and message information.
 type AnthropicError struct {
-	Type  string `json:"type"`
+	Type  string `json:"type"` // Type of error
 	Error struct {
-		Type    string `json:"type"`
-		Message string `json:"message"`
-	} `json:"error"`
+		Type    string `json:"type"`    // Error type
+		Message string `json:"message"` // Error message
+	} `json:"error"` // Error details
 }
 
-// AnthropicProvider implements the Provider interface for Anthropic's Claude API
+// AnthropicProvider implements the Provider interface for Anthropic's Claude API.
 type AnthropicProvider struct {
-	logger interfaces.Logger
-	client *fasthttp.Client
+	logger interfaces.Logger // Logger for provider operations
+	client *fasthttp.Client  // HTTP client for API requests
 }
 
-// NewAnthropicProvider creates a new AnthropicProvider instance
+// NewAnthropicProvider creates a new Anthropic provider instance.
+// It initializes the HTTP client with the provided configuration and sets up response pools.
+// The client is configured with timeouts, concurrency limits, and optional proxy settings.
 func NewAnthropicProvider(config *interfaces.ProviderConfig, logger interfaces.Logger) *AnthropicProvider {
 	client := &fasthttp.Client{
 		ReadTimeout:     time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds),
@@ -71,6 +83,7 @@ func NewAnthropicProvider(config *interfaces.ProviderConfig, logger interfaces.L
 		MaxConnsPerHost: config.ConcurrencyAndBufferSize.BufferSize,
 	}
 
+	// Pre-warm response pools
 	for range config.ConcurrencyAndBufferSize.Concurrency {
 		anthropicTextResponsePool.Put(&AnthropicTextResponse{})
 		anthropicChatResponsePool.Put(&AnthropicChatResponse{})
@@ -86,10 +99,14 @@ func NewAnthropicProvider(config *interfaces.ProviderConfig, logger interfaces.L
 	}
 }
 
+// GetProviderKey returns the provider identifier for Anthropic.
 func (provider *AnthropicProvider) GetProviderKey() interfaces.SupportedModelProvider {
 	return interfaces.Anthropic
 }
 
+// PrepareTextCompletionParams prepares text completion parameters for Anthropic's API.
+// It handles parameter mapping and conversion to the format expected by Anthropic.
+// Returns the modified parameters map.
 func (provider *AnthropicProvider) PrepareTextCompletionParams(params map[string]interface{}) map[string]interface{} {
 	// Check if there is a key entry for max_tokens
 	if maxTokens, exists := params["max_tokens"]; exists {
@@ -103,6 +120,9 @@ func (provider *AnthropicProvider) PrepareTextCompletionParams(params map[string
 	return params
 }
 
+// PrepareToolChoices prepares tool choice parameters for Anthropic's API.
+// It handles conversion of tool choice parameters to the format expected by Anthropic.
+// Returns the modified parameters map.
 func (provider *AnthropicProvider) PrepareToolChoices(params map[string]interface{}) map[string]interface{} {
 	toolChoice, exists := params["tool_choice"]
 	if !exists {
@@ -135,6 +155,9 @@ func (provider *AnthropicProvider) PrepareToolChoices(params map[string]interfac
 	return params
 }
 
+// CompleteRequest sends a request to Anthropic's API and handles the response.
+// It constructs the API URL, sets up authentication, and processes the response.
+// Returns the response body or an error if the request fails.
 func (provider *AnthropicProvider) CompleteRequest(requestBody map[string]interface{}, url string, key string) ([]byte, *interfaces.BifrostError) {
 	// Marshal the request body
 	jsonData, err := json.Marshal(requestBody)
@@ -189,7 +212,9 @@ func (provider *AnthropicProvider) CompleteRequest(requestBody map[string]interf
 	return body, nil
 }
 
-// TextCompletion implements text completion using Anthropic's API
+// TextCompletion performs a text completion request to Anthropic's API.
+// It formats the request, sends it to Anthropic, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *AnthropicProvider) TextCompletion(model, key, text string, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	preparedParams := provider.PrepareTextCompletionParams(prepareParams(params))
 
@@ -241,7 +266,9 @@ func (provider *AnthropicProvider) TextCompletion(model, key, text string, param
 	return bifrostResponse, nil
 }
 
-// ChatCompletion implements chat completion using Anthropic's API
+// ChatCompletion performs a chat completion request to Anthropic's API.
+// It formats the request, sends it to Anthropic, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *AnthropicProvider) ChatCompletion(model, key string, messages []interfaces.Message, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	// Format messages for Anthropic API
 	var formattedMessages []map[string]interface{}
diff --git a/providers/azure.go b/providers/azure.go
index d8321c9ddf..2684e3f9bb 100644
--- a/providers/azure.go
+++ b/providers/azure.go
@@ -1,3 +1,5 @@
+// Package providers implements various LLM providers and their utility functions.
+// This file contains the Azure OpenAI provider implementation.
 package providers
 
 import (
@@ -11,46 +13,54 @@ import (
 	"github.com/maximhq/maxim-go"
 )
 
+// AzureTextResponse represents the response structure from Azure's text completion API.
+// It includes completion choices, model information, and usage statistics.
 type AzureTextResponse struct {
-	ID      string `json:"id"`
-	Object  string `json:"object"` // text.completion or chat.completion
+	ID      string `json:"id"`     // Unique identifier for the completion
+	Object  string `json:"object"` // Type of completion (always "text.completion")
 	Choices []struct {
-		FinishReason *string                          `json:"finish_reason,omitempty"`
-		Index        int                              `json:"index"`
-		Text         string                           `json:"text"`
-		LogProbs     interfaces.TextCompletionLogProb `json:"logprobs"`
+		FinishReason *string                          `json:"finish_reason,omitempty"` // Reason for completion termination
+		Index        int                              `json:"index"`                   // Index of the choice
+		Text         string                           `json:"text"`                    // Generated text
+		LogProbs     interfaces.TextCompletionLogProb `json:"logprobs"`                // Log probabilities
 	} `json:"choices"`
-	Model             string              `json:"model"`
-	Created           int                 `json:"created"` // The Unix timestamp (in seconds).
-	SystemFingerprint *string             `json:"system_fingerprint"`
-	Usage             interfaces.LLMUsage `json:"usage"`
+	Model             string              `json:"model"`              // Model used for the completion
+	Created           int                 `json:"created"`            // Unix timestamp of completion creation
+	SystemFingerprint *string             `json:"system_fingerprint"` // System fingerprint for the request
+	Usage             interfaces.LLMUsage `json:"usage"`              // Token usage statistics
 }
 
+// AzureChatResponse represents the response structure from Azure's chat completion API.
+// It includes completion choices, model information, and usage statistics.
 type AzureChatResponse struct {
-	ID                string                             `json:"id"`
-	Object            string                             `json:"object"` // text.completion or chat.completion
-	Choices           []interfaces.BifrostResponseChoice `json:"choices"`
-	Model             string                             `json:"model"`
-	Created           int                                `json:"created"` // The Unix timestamp (in seconds).
-	SystemFingerprint *string                            `json:"system_fingerprint"`
-	Usage             interfaces.LLMUsage                `json:"usage"`
+	ID                string                             `json:"id"`                 // Unique identifier for the completion
+	Object            string                             `json:"object"`             // Type of completion (always "chat.completion")
+	Choices           []interfaces.BifrostResponseChoice `json:"choices"`            // Array of completion choices
+	Model             string                             `json:"model"`              // Model used for the completion
+	Created           int                                `json:"created"`            // Unix timestamp of completion creation
+	SystemFingerprint *string                            `json:"system_fingerprint"` // System fingerprint for the request
+	Usage             interfaces.LLMUsage                `json:"usage"`              // Token usage statistics
 }
 
+// AzureError represents the error response structure from Azure's API.
+// It includes error code and message information.
 type AzureError struct {
 	Error struct {
-		Code    string `json:"code"`
-		Message string `json:"message"`
+		Code    string `json:"code"`    // Error code
+		Message string `json:"message"` // Error message
 	} `json:"error"`
 }
 
-// AzureProvider implements the Provider interface for Azure API
+// AzureProvider implements the Provider interface for Azure's OpenAI API.
 type AzureProvider struct {
-	logger interfaces.Logger
-	client *fasthttp.Client
-	meta   interfaces.MetaConfig
+	logger interfaces.Logger     // Logger for provider operations
+	client *fasthttp.Client      // HTTP client for API requests
+	meta   interfaces.MetaConfig // Azure-specific configuration
 }
 
-// NewAzureProvider creates a new AzureProvider instance
+// NewAzureProvider creates a new Azure provider instance.
+// It initializes the HTTP client with the provided configuration and sets up response pools.
+// The client is configured with timeouts, concurrency limits, and optional proxy settings.
 func NewAzureProvider(config *interfaces.ProviderConfig, logger interfaces.Logger) *AzureProvider {
 	client := &fasthttp.Client{
 		ReadTimeout:     time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds),
@@ -58,8 +68,8 @@ func NewAzureProvider(config *interfaces.ProviderConfig, logger interfaces.Logge
 		MaxConnsPerHost: config.ConcurrencyAndBufferSize.BufferSize,
 	}
 
+	// Pre-warm response pools
 	for range config.ConcurrencyAndBufferSize.Concurrency {
-		// Create and put new objects directly into pools
 		azureChatResponsePool.Put(&AzureChatResponse{})
 		azureTextCompletionResponsePool.Put(&AzureTextResponse{})
 		bifrostResponsePool.Put(&interfaces.BifrostResponse{})
@@ -75,10 +85,14 @@ func NewAzureProvider(config *interfaces.ProviderConfig, logger interfaces.Logge
 	}
 }
 
+// GetProviderKey returns the provider identifier for Azure.
 func (provider *AzureProvider) GetProviderKey() interfaces.SupportedModelProvider {
 	return interfaces.Azure
 }
 
+// PrepareToolChoices prepares tool choice parameters for Azure's API.
+// It handles conversion of tool choice parameters to the format expected by Azure.
+// Returns the modified parameters map.
 func (provider *AzureProvider) PrepareToolChoices(params map[string]interface{}) map[string]interface{} {
 	toolChoice, exists := params["tool_choice"]
 	if !exists {
@@ -111,6 +125,9 @@ func (provider *AzureProvider) PrepareToolChoices(params map[string]interface{})
 	return params
 }
 
+// CompleteRequest sends a request to Azure's API and handles the response.
+// It constructs the API URL, sets up authentication, and processes the response.
+// Returns the response body or an error if the request fails.
 func (provider *AzureProvider) CompleteRequest(requestBody map[string]interface{}, path string, key string, model string) ([]byte, *interfaces.BifrostError) {
 	// Marshal the request body
 	jsonData, err := json.Marshal(requestBody)
@@ -201,7 +218,9 @@ func (provider *AzureProvider) CompleteRequest(requestBody map[string]interface{
 	return body, nil
 }
 
-// TextCompletion implements text completion using Anthropic's API
+// TextCompletion performs a text completion request to Azure's API.
+// It formats the request, sends it to Azure, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *AzureProvider) TextCompletion(model, key, text string, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	preparedParams := prepareParams(params)
 
@@ -248,10 +267,10 @@ func (provider *AzureProvider) TextCompletion(model, key, text string, params *i
 
 	bifrostResponse.ID = response.ID
 	bifrostResponse.Choices = choices
-	bifrostResponse.Usage = response.Usage
 	bifrostResponse.Model = response.Model
 	bifrostResponse.Created = response.Created
 	bifrostResponse.SystemFingerprint = response.SystemFingerprint
+	bifrostResponse.Usage = response.Usage
 	bifrostResponse.ExtraFields = interfaces.BifrostResponseExtraFields{
 		Provider:    interfaces.Azure,
 		RawResponse: rawResponse,
@@ -260,43 +279,21 @@ func (provider *AzureProvider) TextCompletion(model, key, text string, params *i
 	return bifrostResponse, nil
 }
 
-// ChatCompletion implements chat completion using Azure's API
+// ChatCompletion performs a chat completion request to Azure's API.
+// It formats the request, sends it to Azure, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *AzureProvider) ChatCompletion(model, key string, messages []interfaces.Message, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
+	preparedParams := prepareParams(params)
+
 	// Format messages for Azure API
 	var formattedMessages []map[string]interface{}
 	for _, msg := range messages {
-		if msg.ImageContent != nil {
-			var content []map[string]interface{}
-
-			imageContent := map[string]interface{}{
-				"type":      "image_url",
-				"image_url": map[string]interface{}{"url": msg.ImageContent.URL},
-			}
-
-			content = append(content, imageContent)
-
-			// Add text content if present
-			if msg.Content != nil {
-				content = append(content, map[string]interface{}{
-					"type": "text",
-					"text": msg.Content,
-				})
-			}
-
-			formattedMessages = append(formattedMessages, map[string]interface{}{
-				"role":    msg.Role,
-				"content": content,
-			})
-		} else {
-			formattedMessages = append(formattedMessages, map[string]interface{}{
-				"role":    msg.Role,
-				"content": msg.Content,
-			})
-		}
+		formattedMessages = append(formattedMessages, map[string]interface{}{
+			"role":    msg.Role,
+			"content": msg.Content,
+		})
 	}
 
-	preparedParams := prepareParams(params)
-
 	// Merge additional parameters
 	requestBody := mergeConfig(map[string]interface{}{
 		"model":    model,
@@ -316,16 +313,13 @@ func (provider *AzureProvider) ChatCompletion(model, key string, messages []inte
 	bifrostResponse := acquireBifrostResponse()
 	defer releaseBifrostResponse(bifrostResponse)
 
-	// Use enhanced response handler
 	rawResponse, bifrostErr := handleProviderResponse(responseBody, response)
 	if bifrostErr != nil {
 		return nil, bifrostErr
 	}
 
-	// Set response fields
 	bifrostResponse.ID = response.ID
 	bifrostResponse.Choices = response.Choices
-	bifrostResponse.Object = response.Object
 	bifrostResponse.Model = response.Model
 	bifrostResponse.Created = response.Created
 	bifrostResponse.SystemFingerprint = response.SystemFingerprint
diff --git a/providers/bedrock.go b/providers/bedrock.go
index 3b158cb0a5..9532eec53e 100644
--- a/providers/bedrock.go
+++ b/providers/bedrock.go
@@ -1,3 +1,5 @@
+// Package providers implements various LLM providers and their utility functions.
+// This file contains the AWS Bedrock provider implementation.
 package providers
 
 import (
@@ -13,101 +15,125 @@ import (
 	"github.com/maximhq/bifrost/interfaces"
 )
 
+// BedrockAnthropicTextResponse represents the response structure from Bedrock's Anthropic text completion API.
+// It includes the completion text and stop reason information.
 type BedrockAnthropicTextResponse struct {
-	Completion string `json:"completion"`
-	StopReason string `json:"stop_reason"`
-	Stop       string `json:"stop"`
+	Completion string `json:"completion"`  // Generated completion text
+	StopReason string `json:"stop_reason"` // Reason for completion termination
+	Stop       string `json:"stop"`        // Stop sequence that caused completion to stop
 }
 
+// BedrockMistralTextResponse represents the response structure from Bedrock's Mistral text completion API.
+// It includes multiple output choices with their text and stop reasons.
 type BedrockMistralTextResponse struct {
 	Outputs []struct {
-		Text       string `json:"text"`
-		StopReason string `json:"stop_reason"`
-	} `json:"outputs"`
+		Text       string `json:"text"`        // Generated text
+		StopReason string `json:"stop_reason"` // Reason for completion termination
+	} `json:"outputs"` // Array of output choices
 }
 
+// BedrockChatResponse represents the response structure from Bedrock's chat completion API.
+// It includes message content, metrics, and token usage statistics.
 type BedrockChatResponse struct {
 	Metrics struct {
-		Latency int `json:"latencyMs"`
-	} `json:"metrics"`
+		Latency int `json:"latencyMs"` // Response latency in milliseconds
+	} `json:"metrics"` // Performance metrics
 	Output struct {
 		Message struct {
 			Content []struct {
-				Text string `json:"text"`
-			} `json:"content"`
-			Role string `json:"role"`
-		} `json:"message"`
-	} `json:"output"`
-	StopReason string `json:"stopReason"`
+				Text string `json:"text"` // Message content
+			} `json:"content"` // Array of message content
+			Role string `json:"role"` // Role of the message sender
+		} `json:"message"` // Message structure
+	} `json:"output"` // Output structure
+	StopReason string `json:"stopReason"` // Reason for completion termination
 	Usage      struct {
-		InputTokens  int `json:"inputTokens"`
-		OutputTokens int `json:"outputTokens"`
-		TotalTokens  int `json:"totalTokens"`
-	} `json:"usage"`
+		InputTokens  int `json:"inputTokens"`  // Number of input tokens used
+		OutputTokens int `json:"outputTokens"` // Number of output tokens generated
+		TotalTokens  int `json:"totalTokens"`  // Total number of tokens used
+	} `json:"usage"` // Token usage statistics
 }
 
+// BedrockAnthropicSystemMessage represents a system message for Anthropic models.
 type BedrockAnthropicSystemMessage struct {
-	Text string `json:"text"`
+	Text string `json:"text"` // System message text
 }
 
+// BedrockAnthropicTextMessage represents a text message for Anthropic models.
 type BedrockAnthropicTextMessage struct {
-	Type string `json:"type"`
-	Text string `json:"text"`
+	Type string `json:"type"` // Type of message
+	Text string `json:"text"` // Message text
 }
 
+// BedrockMistralContent represents content for Mistral models.
 type BedrockMistralContent struct {
-	Text string `json:"text"`
+	Text string `json:"text"` // Content text
 }
 
+// BedrockMistralChatMessage represents a chat message for Mistral models.
 type BedrockMistralChatMessage struct {
-	Role       interfaces.ModelChatMessageRole `json:"role"`
-	Content    []BedrockMistralContent         `json:"content"`
-	ToolCalls  *[]BedrockMistralToolCall       `json:"tool_calls,omitempty"`
-	ToolCallID *string                         `json:"tool_call_id,omitempty"`
+	Role       interfaces.ModelChatMessageRole `json:"role"`                   // Role of the message sender
+	Content    []BedrockMistralContent         `json:"content"`                // Array of message content
+	ToolCalls  *[]BedrockMistralToolCall       `json:"tool_calls,omitempty"`   // Optional tool calls
+	ToolCallID *string                         `json:"tool_call_id,omitempty"` // Optional tool call ID
 }
 
+// BedrockAnthropicImageMessage represents an image message for Anthropic models.
 type BedrockAnthropicImageMessage struct {
-	Type  string                `json:"type"`
-	Image BedrockAnthropicImage `json:"image"`
+	Type  string                `json:"type"`  // Type of message
+	Image BedrockAnthropicImage `json:"image"` // Image data
 }
 
+// BedrockAnthropicImage represents image data for Anthropic models.
 type BedrockAnthropicImage struct {
-	Format string                      `json:"string"`
-	Source BedrockAnthropicImageSource `json:"source"`
+	Format string                      `json:"string"` // Image format
+	Source BedrockAnthropicImageSource `json:"source"` // Image source
 }
 
+// BedrockAnthropicImageSource represents the source of an image for Anthropic models.
 type BedrockAnthropicImageSource struct {
-	Bytes string `json:"bytes"`
+	Bytes string `json:"bytes"` // Base64 encoded image data
 }
 
+// BedrockMistralToolCall represents a tool call for Mistral models.
 type BedrockMistralToolCall struct {
-	ID       string              `json:"id"`
-	Function interfaces.Function `json:"function"`
+	ID       string              `json:"id"`       // Tool call ID
+	Function interfaces.Function `json:"function"` // Function to call
 }
 
+// BedrockAnthropicToolCall represents a tool call for Anthropic models.
 type BedrockAnthropicToolCall struct {
-	ToolSpec BedrockAnthropicToolSpec `json:"toolSpec"`
+	ToolSpec BedrockAnthropicToolSpec `json:"toolSpec"` // Tool specification
 }
 
+// BedrockAnthropicToolSpec represents a tool specification for Anthropic models.
 type BedrockAnthropicToolSpec struct {
-	Name        string `json:"name"`
-	Description string `json:"description"`
+	Name        string `json:"name"`        // Tool name
+	Description string `json:"description"` // Tool description
 	InputSchema struct {
-		Json interface{} `json:"json"`
-	} `json:"inputSchema"`
+		Json interface{} `json:"json"` // Input schema in JSON format
+	} `json:"inputSchema"` // Input schema structure
 }
 
+// BedrockError represents the error response structure from Bedrock's API.
 type BedrockError struct {
-	Message string `json:"message"`
+	Message string `json:"message"` // Error message
 }
 
+// BedrockProvider implements the Provider interface for AWS Bedrock.
 type BedrockProvider struct {
-	logger interfaces.Logger
-	client *http.Client
-	meta   interfaces.MetaConfig
+	logger interfaces.Logger     // Logger for provider operations
+	client *http.Client          // HTTP client for API requests
+	meta   interfaces.MetaConfig // AWS-specific configuration
 }
 
+// NewBedrockProvider creates a new Bedrock provider instance.
+// It initializes the HTTP client with the provided configuration and sets up response pools.
+// The client is configured with timeouts and AWS-specific settings.
 func NewBedrockProvider(config *interfaces.ProviderConfig, logger interfaces.Logger) *BedrockProvider {
+	client := &http.Client{Timeout: time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds)}
+
+	// Pre-warm response pools
 	for range config.ConcurrencyAndBufferSize.Concurrency {
 		bedrockChatResponsePool.Put(&BedrockChatResponse{})
 		bifrostResponsePool.Put(&interfaces.BifrostResponse{})
@@ -115,15 +141,19 @@ func NewBedrockProvider(config *interfaces.ProviderConfig, logger interfaces.Log
 
 	return &BedrockProvider{
 		logger: logger,
-		client: &http.Client{Timeout: time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds)},
+		client: client,
 		meta:   config.MetaConfig,
 	}
 }
 
+// GetProviderKey returns the provider identifier for Bedrock.
 func (provider *BedrockProvider) GetProviderKey() interfaces.SupportedModelProvider {
 	return interfaces.Bedrock
 }
 
+// CompleteRequest sends a request to Bedrock's API and handles the response.
+// It constructs the API URL, sets up AWS authentication, and processes the response.
+// Returns the response body or an error if the request fails.
 func (provider *BedrockProvider) CompleteRequest(requestBody map[string]interface{}, path string, accessKey string) ([]byte, *interfaces.BifrostError) {
 	if provider.meta == nil {
 		return nil, &interfaces.BifrostError{
@@ -215,6 +245,9 @@ func (provider *BedrockProvider) CompleteRequest(requestBody map[string]interfac
 	return body, nil
 }
 
+// GetTextCompletionResult processes the text completion response from Bedrock.
+// It handles different model types (Anthropic and Mistral) and formats the response.
+// Returns a BifrostResponse containing the completion results or an error if processing fails.
 func (provider *BedrockProvider) GetTextCompletionResult(result []byte, model string) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	switch model {
 	case "anthropic.claude-instant-v1:2":
@@ -300,6 +333,9 @@ func (provider *BedrockProvider) GetTextCompletionResult(result []byte, model st
 	}
 }
 
+// PrepareChatCompletionMessages formats chat messages for Bedrock's API.
+// It handles different model types (Anthropic and Mistral) and formats messages accordingly.
+// Returns a map containing the formatted messages and any system messages, or an error if formatting fails.
 func (provider *BedrockProvider) PrepareChatCompletionMessages(messages []interfaces.Message, model string) (map[string]interface{}, *interfaces.BifrostError) {
 	switch model {
 	case "anthropic.claude-instant-v1:2":
@@ -418,6 +454,9 @@ func (provider *BedrockProvider) PrepareChatCompletionMessages(messages []interf
 	}
 }
 
+// GetChatCompletionTools prepares tool specifications for Bedrock's API.
+// It formats tool definitions for different model types (Anthropic and Mistral).
+// Returns an array of tool specifications for the given model.
 func (provider *BedrockProvider) GetChatCompletionTools(params *interfaces.ModelParameters, model string) []BedrockAnthropicToolCall {
 	var tools []BedrockAnthropicToolCall
 
@@ -457,6 +496,9 @@ func (provider *BedrockProvider) GetChatCompletionTools(params *interfaces.Model
 	return tools
 }
 
+// PrepareTextCompletionParams prepares text completion parameters for Bedrock's API.
+// It handles parameter mapping and conversion for different model types.
+// Returns the modified parameters map with model-specific adjustments.
 func (provider *BedrockProvider) PrepareTextCompletionParams(params map[string]interface{}, model string) map[string]interface{} {
 	switch model {
 	case "anthropic.claude-instant-v1:2":
@@ -477,6 +519,9 @@ func (provider *BedrockProvider) PrepareTextCompletionParams(params map[string]i
 	return params
 }
 
+// TextCompletion performs a text completion request to Bedrock's API.
+// It formats the request, sends it to Bedrock, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *BedrockProvider) TextCompletion(model, key, text string, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	preparedParams := provider.PrepareTextCompletionParams(prepareParams(params), model)
 
@@ -511,6 +556,9 @@ func (provider *BedrockProvider) TextCompletion(model, key, text string, params
 	return result, nil
 }
 
+// ChatCompletion performs a chat completion request to Bedrock's API.
+// It formats the request, sends it to Bedrock, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *BedrockProvider) ChatCompletion(model, key string, messages []interfaces.Message, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	messageBody, err := provider.PrepareChatCompletionMessages(messages, model)
 	if err != nil {
diff --git a/providers/cohere.go b/providers/cohere.go
index 907bfdb3ed..2947684700 100644
--- a/providers/cohere.go
+++ b/providers/cohere.go
@@ -1,3 +1,5 @@
+// Package providers implements various LLM providers and their utility functions.
+// This file contains the Cohere provider implementation.
 package providers
 
 import (
@@ -10,64 +12,79 @@ import (
 	"github.com/valyala/fasthttp"
 )
 
-// CohereParameterDefinition represents a parameter definition for a Cohere tool
+// CohereParameterDefinition represents a parameter definition for a Cohere tool.
+// It defines the type, description, and whether the parameter is required.
 type CohereParameterDefinition struct {
-	Type        string  `json:"type"`
-	Description *string `json:"description,omitempty"`
-	Required    bool    `json:"required"`
+	Type        string  `json:"type"`                  // Type of the parameter
+	Description *string `json:"description,omitempty"` // Optional description of the parameter
+	Required    bool    `json:"required"`              // Whether the parameter is required
 }
 
-// CohereTool represents a tool definition for Cohere API
+// CohereTool represents a tool definition for the Cohere API.
+// It includes the tool's name, description, and parameter definitions.
 type CohereTool struct {
-	Name                 string                               `json:"name"`
-	Description          string                               `json:"description"`
-	ParameterDefinitions map[string]CohereParameterDefinition `json:"parameter_definitions"`
+	Name                 string                               `json:"name"`                  // Name of the tool
+	Description          string                               `json:"description"`           // Description of the tool
+	ParameterDefinitions map[string]CohereParameterDefinition `json:"parameter_definitions"` // Definitions of the tool's parameters
 }
 
+// CohereToolCall represents a tool call made by the Cohere API.
+// It includes the name of the tool and its parameters.
 type CohereToolCall struct {
-	Name       string      `json:"name"`
-	Parameters interface{} `json:"parameters"`
+	Name       string      `json:"name"`       // Name of the tool being called
+	Parameters interface{} `json:"parameters"` // Parameters passed to the tool
 }
 
-// CohereChatResponse represents the response from Cohere's chat API
+// CohereChatResponse represents the response from Cohere's chat API.
+// It includes the response ID, generated text, chat history, and usage statistics.
 type CohereChatResponse struct {
-	ResponseID   string `json:"response_id"`
-	Text         string `json:"text"`
-	GenerationID string `json:"generation_id"`
+	ResponseID   string `json:"response_id"`   // Unique identifier for the response
+	Text         string `json:"text"`          // Generated text response
+	GenerationID string `json:"generation_id"` // ID of the generation
 	ChatHistory  []struct {
-		Role      interfaces.ModelChatMessageRole `json:"role"`
-		Message   string                          `json:"message"`
-		ToolCalls []CohereToolCall                `json:"tool_calls"`
-	} `json:"chat_history"`
-	FinishReason string `json:"finish_reason"`
+		Role      interfaces.ModelChatMessageRole `json:"role"`       // Role of the message sender
+		Message   string                          `json:"message"`    // Content of the message
+		ToolCalls []CohereToolCall                `json:"tool_calls"` // Tool calls made in the message
+	} `json:"chat_history"` // History of the chat conversation
+	FinishReason string `json:"finish_reason"` // Reason for completion termination
 	Meta         struct {
 		APIVersion struct {
-			Version string `json:"version"`
-		} `json:"api_version"`
+			Version string `json:"version"` // Version of the API used
+		} `json:"api_version"` // API version information
 		BilledUnits struct {
-			InputTokens  float64 `json:"input_tokens"`
-			OutputTokens float64 `json:"output_tokens"`
-		} `json:"billed_units"`
+			InputTokens  float64 `json:"input_tokens"`  // Number of input tokens billed
+			OutputTokens float64 `json:"output_tokens"` // Number of output tokens billed
+		} `json:"billed_units"` // Token usage billing information
 		Tokens struct {
-			InputTokens  float64 `json:"input_tokens"`
-			OutputTokens float64 `json:"output_tokens"`
-		} `json:"tokens"`
-	} `json:"meta"`
-	ToolCalls []CohereToolCall `json:"tool_calls"`
+			InputTokens  float64 `json:"input_tokens"`  // Number of input tokens used
+			OutputTokens float64 `json:"output_tokens"` // Number of output tokens generated
+		} `json:"tokens"` // Token usage statistics
+	} `json:"meta"` // Metadata about the response
+	ToolCalls []CohereToolCall `json:"tool_calls"` // Tool calls made in the response
 }
 
+// CohereError represents an error response from the Cohere API.
 type CohereError struct {
-	Message string `json:"message"`
+	Message string `json:"message"` // Error message
 }
 
-// OpenAIProvider implements the Provider interface for OpenAI
+// CohereProvider implements the Provider interface for Cohere.
 type CohereProvider struct {
-	logger interfaces.Logger
-	client *fasthttp.Client
+	logger interfaces.Logger // Logger for provider operations
+	client *fasthttp.Client  // HTTP client for API requests
 }
 
-// NewOpenAIProvider creates a new OpenAI provider instance
+// NewCohereProvider creates a new Cohere provider instance.
+// It initializes the HTTP client with the provided configuration and sets up response pools.
+// The client is configured with timeouts and connection limits.
 func NewCohereProvider(config *interfaces.ProviderConfig, logger interfaces.Logger) *CohereProvider {
+	client := &fasthttp.Client{
+		ReadTimeout:     time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds),
+		WriteTimeout:    time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds),
+		MaxConnsPerHost: config.ConcurrencyAndBufferSize.BufferSize,
+	}
+
+	// Pre-warm response pools
 	for range config.ConcurrencyAndBufferSize.Concurrency {
 		cohereResponsePool.Put(&CohereChatResponse{})
 		bifrostResponsePool.Put(&interfaces.BifrostResponse{})
@@ -75,18 +92,17 @@ func NewCohereProvider(config *interfaces.ProviderConfig, logger interfaces.Logg
 
 	return &CohereProvider{
 		logger: logger,
-		client: &fasthttp.Client{
-			ReadTimeout:     time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds),
-			WriteTimeout:    time.Second * time.Duration(config.NetworkConfig.DefaultRequestTimeoutInSeconds),
-			MaxConnsPerHost: config.ConcurrencyAndBufferSize.BufferSize,
-		},
+		client: client,
 	}
 }
 
+// GetProviderKey returns the provider identifier for Cohere.
 func (provider *CohereProvider) GetProviderKey() interfaces.SupportedModelProvider {
 	return interfaces.Cohere
 }
 
+// TextCompletion is not supported by the Cohere provider.
+// Returns an error indicating that text completion is not supported.
 func (provider *CohereProvider) TextCompletion(model, key, text string, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	return nil, &interfaces.BifrostError{
 		IsBifrostError: false,
@@ -96,6 +112,9 @@ func (provider *CohereProvider) TextCompletion(model, key, text string, params *
 	}
 }
 
+// ChatCompletion performs a chat completion request to the Cohere API.
+// It formats the request, sends it to Cohere, and processes the response.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *CohereProvider) ChatCompletion(model, key string, messages []interfaces.Message, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	// Get the last message and chat history
 	lastMessage := messages[len(messages)-1]
@@ -278,7 +297,8 @@ func (provider *CohereProvider) ChatCompletion(model, key string, messages []int
 	return bifrostResponse, nil
 }
 
-// Helper function to convert chat history to the correct type
+// convertChatHistory converts Cohere's chat history format to Bifrost's format for standardization.
+// It transforms the chat history messages and their tool calls.
 func convertChatHistory(history []struct {
 	Role      interfaces.ModelChatMessageRole `json:"role"`
 	Message   string                          `json:"message"`
@@ -313,8 +333,3 @@ func convertChatHistory(history []struct {
 	}
 	return &converted
 }
-
-// Helper function to create a pointer to a float64
-func float64Ptr(f float64) *float64 {
-	return &f
-}
diff --git a/providers/openai.go b/providers/openai.go
index 9ec03e3c76..e2ea88e18c 100644
--- a/providers/openai.go
+++ b/providers/openai.go
@@ -1,3 +1,5 @@
+// Package providers implements various LLM providers and their utility functions.
+// This file contains the OpenAI provider implementation.
 package providers
 
 import (
@@ -8,36 +10,42 @@ import (
 	"github.com/valyala/fasthttp"
 )
 
+// OpenAIResponse represents the response structure from the OpenAI API.
+// It includes completion choices, model information, and usage statistics.
 type OpenAIResponse struct {
-	ID                string                             `json:"id"`
-	Object            string                             `json:"object"` // text.completion or chat.completion
-	Choices           []interfaces.BifrostResponseChoice `json:"choices"`
-	Model             string                             `json:"model"`
-	Created           int                                `json:"created"` // The Unix timestamp (in seconds).
-	ServiceTier       *string                            `json:"service_tier"`
-	SystemFingerprint *string                            `json:"system_fingerprint"`
-	Usage             interfaces.LLMUsage                `json:"usage"`
+	ID                string                             `json:"id"`                 // Unique identifier for the completion
+	Object            string                             `json:"object"`             // Type of completion (text.completion or chat.completion)
+	Choices           []interfaces.BifrostResponseChoice `json:"choices"`            // Array of completion choices
+	Model             string                             `json:"model"`              // Model used for the completion
+	Created           int                                `json:"created"`            // Unix timestamp of completion creation
+	ServiceTier       *string                            `json:"service_tier"`       // Service tier used for the request
+	SystemFingerprint *string                            `json:"system_fingerprint"` // System fingerprint for the request
+	Usage             interfaces.LLMUsage                `json:"usage"`              // Token usage statistics
 }
 
+// OpenAIError represents the error response structure from the OpenAI API.
+// It includes detailed error information and event tracking.
 type OpenAIError struct {
-	EventID string `json:"event_id"`
-	Type    string `json:"type"`
+	EventID string `json:"event_id"` // Unique identifier for the error event
+	Type    string `json:"type"`     // Type of error
 	Error   struct {
-		Type    string      `json:"type"`
-		Code    string      `json:"code"`
-		Message string      `json:"message"`
-		Param   interface{} `json:"param"`
-		EventID string      `json:"event_id"`
+		Type    string      `json:"type"`     // Error type
+		Code    string      `json:"code"`     // Error code
+		Message string      `json:"message"`  // Error message
+		Param   interface{} `json:"param"`    // Parameter that caused the error
+		EventID string      `json:"event_id"` // Event ID for tracking
 	} `json:"error"`
 }
 
-// OpenAIProvider implements the Provider interface for OpenAI
+// OpenAIProvider implements the Provider interface for OpenAI's API.
 type OpenAIProvider struct {
-	logger interfaces.Logger
-	client *fasthttp.Client
+	logger interfaces.Logger // Logger for provider operations
+	client *fasthttp.Client  // HTTP client for API requests
 }
 
-// NewOpenAIProvider creates a new OpenAI provider instance
+// NewOpenAIProvider creates a new OpenAI provider instance.
+// It initializes the HTTP client with the provided configuration and sets up response pools.
+// The client is configured with timeouts, concurrency limits, and optional proxy settings.
 func NewOpenAIProvider(config *interfaces.ProviderConfig, logger interfaces.Logger) *OpenAIProvider {
 	// Create the client
 	client := &fasthttp.Client{
@@ -46,8 +54,8 @@ func NewOpenAIProvider(config *interfaces.ProviderConfig, logger interfaces.Logg
 		MaxConnsPerHost: config.ConcurrencyAndBufferSize.BufferSize,
 	}
 
+	// Pre-warm response pools
 	for range config.ConcurrencyAndBufferSize.Concurrency {
-		// Create and put new objects directly into pools
 		openAIResponsePool.Put(&OpenAIResponse{})
 		bifrostResponsePool.Put(&interfaces.BifrostResponse{})
 	}
@@ -61,11 +69,13 @@ func NewOpenAIProvider(config *interfaces.ProviderConfig, logger interfaces.Logg
 	}
 }
 
+// GetProviderKey returns the provider identifier for OpenAI.
 func (provider *OpenAIProvider) GetProviderKey() interfaces.SupportedModelProvider {
 	return interfaces.OpenAI
 }
 
-// TextCompletion performs text completion
+// TextCompletion is not supported by the OpenAI provider.
+// Returns an error indicating that text completion is not available.
 func (provider *OpenAIProvider) TextCompletion(model, key, text string, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	return nil, &interfaces.BifrostError{
 		IsBifrostError: false,
@@ -75,6 +85,9 @@ func (provider *OpenAIProvider) TextCompletion(model, key, text string, params *
 	}
 }
 
+// ChatCompletion performs a chat completion request to the OpenAI API.
+// It supports both text and image content in messages.
+// Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *OpenAIProvider) ChatCompletion(model, key string, messages []interfaces.Message, params *interfaces.ModelParameters) (*interfaces.BifrostResponse, *interfaces.BifrostError) {
 	// Format messages for OpenAI API
 	var formattedMessages []map[string]interface{}
diff --git a/providers/pool.go b/providers/pool.go
index 4c557962c1..5c39952628 100644
--- a/providers/pool.go
+++ b/providers/pool.go
@@ -1,3 +1,6 @@
+// Package providers implements various LLM providers and their response pooling mechanisms.
+// This file contains the implementation of object pools for different provider responses
+// to optimize memory allocation and garbage collection.
 package providers
 
 import (
@@ -6,166 +9,195 @@ import (
 	"github.com/maximhq/bifrost/interfaces"
 )
 
-// openAIResponsePool provides a pool for OpenAI response objects
+// Inital Memory Allocations in the pools are done in provider specific files,
+// taking concurrency provided in the account interface implementation as the initial pool size.
+
+// openAIResponsePool provides a pool for OpenAI response objects.
+// This pool is used to reuse OpenAIResponse objects to reduce memory allocations.
 var openAIResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &OpenAIResponse{}
 	},
 }
 
-// azureResponsePool provides a pool for Azure response objects
+// azureChatResponsePool provides a pool for Azure chat response objects.
+// This pool is used to reuse AzureChatResponse objects to reduce memory allocations.
 var azureChatResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &AzureChatResponse{}
 	},
 }
 
-// azureTextCompletionResponsePool provides a pool for Azure text completion response objects
+// azureTextCompletionResponsePool provides a pool for Azure text completion response objects.
+// This pool is used to reuse AzureTextResponse objects to reduce memory allocations.
 var azureTextCompletionResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &AzureTextResponse{}
 	},
 }
 
-// cohereResponsePool provides a pool for Cohere response objects
+// cohereResponsePool provides a pool for Cohere response objects.
+// This pool is used to reuse CohereChatResponse objects to reduce memory allocations.
 var cohereResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &CohereChatResponse{}
 	},
 }
 
-// bedrockResponsePool provides a pool for Bedrock response objects
+// bedrockChatResponsePool provides a pool for Bedrock response objects.
+// This pool is used to reuse BedrockChatResponse objects to reduce memory allocations.
 var bedrockChatResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &BedrockChatResponse{}
 	},
 }
 
-// anthropicResponsePool provides a pool for Anthropic response objects
+// anthropicChatResponsePool provides a pool for Anthropic chat response objects.
+// This pool is used to reuse AnthropicChatResponse objects to reduce memory allocations.
 var anthropicChatResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &AnthropicChatResponse{}
 	},
 }
 
+// anthropicTextResponsePool provides a pool for Anthropic text response objects.
+// This pool is used to reuse AnthropicTextResponse objects to reduce memory allocations.
 var anthropicTextResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &AnthropicTextResponse{}
 	},
 }
 
-// bifrostResponsePool provides a pool for Bifrost response objects
+// bifrostResponsePool provides a pool for Bifrost response objects.
+// This pool is used to reuse BifrostResponse objects to reduce memory allocations.
 var bifrostResponsePool = sync.Pool{
 	New: func() interface{} {
 		return &interfaces.BifrostResponse{}
 	},
 }
 
-// acquireOpenAIResponse gets an OpenAI response from the pool
+// acquireOpenAIResponse gets an OpenAI response from the pool and resets it.
+// Returns a clean OpenAIResponse object ready for use.
 func acquireOpenAIResponse() *OpenAIResponse {
 	resp := openAIResponsePool.Get().(*OpenAIResponse)
 	*resp = OpenAIResponse{} // Reset the struct
 	return resp
 }
 
-// releaseOpenAIResponse returns an OpenAI response to the pool
+// releaseOpenAIResponse returns an OpenAI response to the pool.
+// The response object will be reused in future allocations.
 func releaseOpenAIResponse(resp *OpenAIResponse) {
 	if resp != nil {
 		openAIResponsePool.Put(resp)
 	}
 }
 
-// acquireAzureChatResponse gets an Azure response from the pool
+// acquireAzureChatResponse gets an Azure chat response from the pool and resets it.
+// Returns a clean AzureChatResponse object ready for use.
 func acquireAzureChatResponse() *AzureChatResponse {
 	resp := azureChatResponsePool.Get().(*AzureChatResponse)
 	*resp = AzureChatResponse{} // Reset the struct
 	return resp
 }
 
-// releaseAzureChatResponse returns an Azure response to the pool
+// releaseAzureChatResponse returns an Azure chat response to the pool.
+// The response object will be reused in future allocations.
 func releaseAzureChatResponse(resp *AzureChatResponse) {
 	if resp != nil {
 		azureChatResponsePool.Put(resp)
 	}
 }
 
-// acquireAzureTextResponse gets an Azure text completion response from the pool
+// acquireAzureTextResponse gets an Azure text completion response from the pool and resets it.
+// Returns a clean AzureTextResponse object ready for use.
 func acquireAzureTextResponse() *AzureTextResponse {
 	resp := azureTextCompletionResponsePool.Get().(*AzureTextResponse)
 	*resp = AzureTextResponse{} // Reset the struct
 	return resp
 }
 
-// releaseAzureTextResponse returns an Azure text completion response to the pool
+// releaseAzureTextResponse returns an Azure text completion response to the pool.
+// The response object will be reused in future allocations.
 func releaseAzureTextResponse(resp *AzureTextResponse) {
 	if resp != nil {
 		azureTextCompletionResponsePool.Put(resp)
 	}
 }
 
-// acquireCohereResponse gets a Cohere response from the pool
+// acquireCohereResponse gets a Cohere response from the pool and resets it.
+// Returns a clean CohereChatResponse object ready for use.
 func acquireCohereResponse() *CohereChatResponse {
 	resp := cohereResponsePool.Get().(*CohereChatResponse)
 	*resp = CohereChatResponse{} // Reset the struct
 	return resp
 }
 
-// releaseCohereResponse returns a Cohere response to the pool
+// releaseCohereResponse returns a Cohere response to the pool.
+// The response object will be reused in future allocations.
 func releaseCohereResponse(resp *CohereChatResponse) {
 	if resp != nil {
 		cohereResponsePool.Put(resp)
 	}
 }
 
-// AcquireBedrockResponse gets a Bedrock response from the pool
+// acquireBedrockChatResponse gets a Bedrock response from the pool and resets it.
+// Returns a clean BedrockChatResponse object ready for use.
 func acquireBedrockChatResponse() *BedrockChatResponse {
 	resp := bedrockChatResponsePool.Get().(*BedrockChatResponse)
 	*resp = BedrockChatResponse{} // Reset the struct
 	return resp
 }
 
-// ReleaseBedrockResponse returns a Bedrock response to the pool
+// releaseBedrockChatResponse returns a Bedrock response to the pool.
+// The response object will be reused in future allocations.
 func releaseBedrockChatResponse(resp *BedrockChatResponse) {
 	if resp != nil {
 		bedrockChatResponsePool.Put(resp)
 	}
 }
 
-// AcquireAnthropicResponse gets an Anthropic response from the pool
+// acquireAnthropicChatResponse gets an Anthropic chat response from the pool and resets it.
+// Returns a clean AnthropicChatResponse object ready for use.
 func acquireAnthropicChatResponse() *AnthropicChatResponse {
 	resp := anthropicChatResponsePool.Get().(*AnthropicChatResponse)
 	*resp = AnthropicChatResponse{} // Reset the struct
 	return resp
 }
 
-// ReleaseAnthropicResponse returns an Anthropic response to the pool
+// releaseAnthropicChatResponse returns an Anthropic chat response to the pool.
+// The response object will be reused in future allocations.
 func releaseAnthropicChatResponse(resp *AnthropicChatResponse) {
 	if resp != nil {
 		anthropicChatResponsePool.Put(resp)
 	}
 }
 
+// acquireAnthropicTextResponse gets an Anthropic text response from the pool and resets it.
+// Returns a clean AnthropicTextResponse object ready for use.
 func acquireAnthropicTextResponse() *AnthropicTextResponse {
 	resp := anthropicTextResponsePool.Get().(*AnthropicTextResponse)
 	*resp = AnthropicTextResponse{} // Reset the struct
 	return resp
 }
 
-// releaseAnthropicTextResponse returns an Anthropic text response to the pool
+// releaseAnthropicTextResponse returns an Anthropic text response to the pool.
+// The response object will be reused in future allocations.
 func releaseAnthropicTextResponse(resp *AnthropicTextResponse) {
 	if resp != nil {
 		anthropicTextResponsePool.Put(resp)
 	}
 }
 
-// acquireBifrostResponse gets a Bifrost response from the pool
+// acquireBifrostResponse gets a Bifrost response from the pool and resets it.
+// Returns a clean BifrostResponse object ready for use.
 func acquireBifrostResponse() *interfaces.BifrostResponse {
 	resp := bifrostResponsePool.Get().(*interfaces.BifrostResponse)
 	*resp = interfaces.BifrostResponse{} // Reset the struct
 	return resp
 }
 
-// releaseBifrostResponse returns a Bifrost response to the pool
+// releaseBifrostResponse returns a Bifrost response to the pool.
+// The response object will be reused in future allocations.
 func releaseBifrostResponse(resp *interfaces.BifrostResponse) {
 	if resp != nil {
 		bifrostResponsePool.Put(resp)
diff --git a/providers/utils.go b/providers/utils.go
index f258874135..a1cf70eee3 100644
--- a/providers/utils.go
+++ b/providers/utils.go
@@ -1,3 +1,5 @@
+// Package providers implements various LLM providers and their utility functions.
+// This file contains common utility functions used across different provider implementations.
 package providers
 
 import (
@@ -26,7 +28,9 @@ import (
 	"github.com/aws/aws-sdk-go-v2/config"
 )
 
-// mergeConfig merges default config with custom parameters
+// mergeConfig merges a default configuration map with custom parameters.
+// It creates a new map containing all default values, then overrides them with any custom values.
+// Returns a new map containing the merged configuration.
 func mergeConfig(defaultConfig map[string]interface{}, customParams map[string]interface{}) map[string]interface{} {
 	merged := make(map[string]interface{})
 
@@ -43,6 +47,10 @@ func mergeConfig(defaultConfig map[string]interface{}, customParams map[string]i
 	return merged
 }
 
+// prepareParams converts ModelParameters into a flat map of parameters.
+// It handles both standard fields and extra parameters, using reflection to process
+// the struct fields and their JSON tags.
+// Returns a map containing all parameters ready for use in API requests.
 func prepareParams(params *interfaces.ModelParameters) map[string]interface{} {
 	flatParams := make(map[string]interface{})
 
@@ -86,6 +94,11 @@ func prepareParams(params *interfaces.ModelParameters) map[string]interface{} {
 	return flatParams
 }
 
+// signAWSRequest signs an HTTP request using AWS Signature Version 4.
+// It is used in providers like Bedrock.
+// It sets required headers, calculates the request body hash, and signs the request
+// using the provided AWS credentials.
+// Returns a BifrostError if signing fails.
 func signAWSRequest(req *http.Request, accessKey, secretKey string, sessionToken *string, region, service string) *interfaces.BifrostError {
 	// Set required headers before signing
 	req.Header.Set("Content-Type", "application/json")
@@ -167,7 +180,9 @@ func signAWSRequest(req *http.Request, accessKey, secretKey string, sessionToken
 	return nil
 }
 
-// configureProxy sets up the proxy for the fasthttp client
+// configureProxy sets up a proxy for the fasthttp client based on the provided configuration.
+// It supports HTTP, SOCKS5, and environment-based proxy configurations.
+// Returns the configured client or the original client if proxy configuration is invalid.
 func configureProxy(client *fasthttp.Client, proxyConfig *interfaces.ProxyConfig, logger interfaces.Logger) *fasthttp.Client {
 	if proxyConfig == nil {
 		return client
@@ -218,6 +233,9 @@ func configureProxy(client *fasthttp.Client, proxyConfig *interfaces.ProxyConfig
 	return client
 }
 
+// handleProviderAPIError processes error responses from provider APIs.
+// It attempts to unmarshal the error response and returns a BifrostError
+// with the appropriate status code and error information.
 func handleProviderAPIError(resp *fasthttp.Response, errorResp any) *interfaces.BifrostError {
 	if err := json.Unmarshal(resp.Body(), &errorResp); err != nil {
 		return &interfaces.BifrostError{
@@ -238,7 +256,9 @@ func handleProviderAPIError(resp *fasthttp.Response, errorResp any) *interfaces.
 	}
 }
 
-// handleProviderResponse handles common response parsing logic and returns Bifrost errors
+// handleProviderResponse handles common response parsing logic for provider responses.
+// It attempts to parse the response body into the provided response type
+// and returns either the parsed response or a BifrostError if parsing fails.
 func handleProviderResponse[T any](responseBody []byte, response *T) (interface{}, *interfaces.BifrostError) {
 	var rawResponse interface{}
 
@@ -278,3 +298,9 @@ func handleProviderResponse[T any](responseBody []byte, response *T) (interface{
 
 	return rawResponse, nil
 }
+
+// float64Ptr creates a pointer to a float64 value.
+// This is a helper function for creating pointers to float64 values.
+func float64Ptr(f float64) *float64 {
+	return &f
+}
diff --git a/tests/account.go b/tests/account.go
index b784f26a45..2fe96bd30c 100644
--- a/tests/account.go
+++ b/tests/account.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -11,15 +14,40 @@ import (
 	"github.com/maximhq/maxim-go"
 )
 
-// BaseAccount provides a basic implementation of the Account interface for Anthropic and OpenAI providers
+// BaseAccount provides a test implementation of the Account interface.
+// It implements basic account functionality for testing purposes, supporting
+// multiple AI providers including OpenAI, Anthropic, Bedrock, Cohere, and Azure.
+// The implementation uses environment variables from the .env file for API keys and provides
+// default configurations suitable for testing.
 type BaseAccount struct{}
 
-// GetInitiallyConfiguredProviderKeys returns all provider keys
+// GetInitiallyConfiguredProviders returns the list of initially supported providers.
+// This implementation returns OpenAI, Anthropic, and Bedrock as the default providers.
+//
+// Returns:
+//   - []interfaces.SupportedModelProvider: A slice containing the supported provider identifiers
+//   - error: Always returns nil as this implementation doesn't produce errors
 func (baseAccount *BaseAccount) GetInitiallyConfiguredProviders() ([]interfaces.SupportedModelProvider, error) {
-	return []interfaces.SupportedModelProvider{interfaces.OpenAI, interfaces.Anthropic, interfaces.Bedrock}, nil
+	return []interfaces.SupportedModelProvider{interfaces.OpenAI, interfaces.Anthropic, interfaces.Bedrock, interfaces.Cohere, interfaces.Azure}, nil
 }
 
-// GetKeysForProvider returns all keys associated with a provider
+// GetKeysForProvider returns the API keys and associated models for a given provider.
+// It retrieves API keys from environment variables and maps them to their supported models.
+// Each key includes a weight value for load balancing purposes.
+//
+// Parameters:
+//   - providerKey: The identifier of the provider to get keys for
+//
+// Returns:
+//   - []interfaces.Key: A slice of Key objects containing API keys and their configurations
+//   - error: An error if the provider is not supported
+//
+// Environment Variables Used:
+//   - OPEN_AI_API_KEY: API key for OpenAI
+//   - ANTHROPIC_API_KEY: API key for Anthropic
+//   - BEDROCK_API_KEY: API key for AWS Bedrock
+//   - COHERE_API_KEY: API key for Cohere
+//   - AZURE_API_KEY: API key for Azure OpenAI
 func (baseAccount *BaseAccount) GetKeysForProvider(providerKey interfaces.SupportedModelProvider) ([]interfaces.Key, error) {
 	switch providerKey {
 	case interfaces.OpenAI:
@@ -62,13 +90,36 @@ func (baseAccount *BaseAccount) GetKeysForProvider(providerKey interfaces.Suppor
 				Weight: 1.0,
 			},
 		}, nil
-
 	default:
 		return nil, fmt.Errorf("unsupported provider: %s", providerKey)
 	}
 }
 
-// GetConcurrencyAndBufferSizeForProvider returns the concurrency and buffer size settings for a provider
+// GetConfigForProvider returns the configuration settings for a given provider.
+// It provides standardized configuration settings for network operations,
+// concurrency, and provider-specific metadata.
+//
+// Parameters:
+//   - providerKey: The identifier of the provider to get configuration for
+//
+// Returns:
+//   - *interfaces.ProviderConfig: Configuration settings for the provider, including:
+//   - Network settings (timeouts, retries, backoff)
+//   - Concurrency and buffer size settings
+//   - Provider-specific metadata (for Bedrock and Azure)
+//   - error: An error if the provider is not supported
+//
+// Environment Variables Used:
+//   - BEDROCK_ACCESS_KEY: AWS access key for Bedrock configuration
+//   - AZURE_ENDPOINT: Azure endpoint for Azure OpenAI configuration
+//
+// Default Settings:
+//   - Request Timeout: 30 seconds
+//   - Max Retries: 1
+//   - Initial Backoff: 100ms
+//   - Max Backoff: 2s
+//   - Concurrency: 3
+//   - Buffer Size: 10
 func (baseAccount *BaseAccount) GetConfigForProvider(providerKey interfaces.SupportedModelProvider) (*interfaces.ProviderConfig, error) {
 	switch providerKey {
 	case interfaces.OpenAI:
diff --git a/tests/anthropic_test.go b/tests/anthropic_test.go
index b7293ee38c..0a1153125b 100644
--- a/tests/anthropic_test.go
+++ b/tests/anthropic_test.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
diff --git a/tests/azure_test.go b/tests/azure_test.go
index 247737849d..9d4255d799 100644
--- a/tests/azure_test.go
+++ b/tests/azure_test.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -16,7 +19,7 @@ func TestAzure(t *testing.T) {
 	config := TestConfig{
 		Provider:       interfaces.Azure,
 		ChatModel:      "gpt-4o",
-		SetupText:      false,
+		SetupText:      false, // gpt-4o does not support text completion
 		SetupToolCalls: true,
 		SetupImage:     true,
 		SetupBaseImage: false,
diff --git a/tests/bedrock_test.go b/tests/bedrock_test.go
index b745e572c2..7dafa6fbc1 100644
--- a/tests/bedrock_test.go
+++ b/tests/bedrock_test.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
diff --git a/tests/cohere_test.go b/tests/cohere_test.go
index de58fa1a87..2699062798 100644
--- a/tests/cohere_test.go
+++ b/tests/cohere_test.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -16,7 +19,7 @@ func TestCohere(t *testing.T) {
 	config := TestConfig{
 		Provider:       interfaces.Cohere,
 		ChatModel:      "command-a-03-2025",
-		SetupText:      false,
+		SetupText:      false, // Cohere does not support text completion
 		SetupToolCalls: true,
 		SetupImage:     false,
 		SetupBaseImage: false,
diff --git a/tests/openai_test.go b/tests/openai_test.go
index d1d1644678..9a9eca2b0d 100644
--- a/tests/openai_test.go
+++ b/tests/openai_test.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -16,6 +19,7 @@ func TestOpenAI(t *testing.T) {
 	config := TestConfig{
 		Provider:       interfaces.OpenAI,
 		ChatModel:      "gpt-4o-mini",
+		SetupText:      false, // OpenAI does not support text completion
 		SetupToolCalls: true,
 		SetupImage:     true,
 		SetupBaseImage: false,
diff --git a/tests/plugin.go b/tests/plugin.go
index 12395435a3..16486730c1 100644
--- a/tests/plugin.go
+++ b/tests/plugin.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -11,17 +14,45 @@ import (
 	"github.com/maximhq/maxim-go/logging"
 )
 
-// Define a custom type for context key to avoid collisions
+// This file contains the Plugin implementation using maxim's logger for testing purposes.
+// If you wish to not use maxim's logger, you pass nil in the Plugins field when initializing Bifrost in tests/setup.go, or implement your own Plugin.
+
+// contextKey is a custom type for context keys to prevent key collisions in the context.
+// It provides type safety for context values and ensures that context keys are unique
+// across different packages.
 type contextKey string
 
+// traceIDKey is the context key used to store and retrieve trace IDs.
+// This constant provides a consistent key for tracking request traces
+// throughout the request/response lifecycle.
 const (
 	traceIDKey contextKey = "traceID"
 )
 
+// Plugin implements the interfaces.Plugin interface for testing purposes.
+// It provides request and response tracing functionality using the Maxim logger,
+// allowing detailed tracking of requests and responses during testing.
+//
+// Fields:
+//   - logger: A Maxim logger instance used for tracing requests and responses
 type Plugin struct {
 	logger *logging.Logger
 }
 
+// PreHook is called before a request is processed by Bifrost.
+// It creates a new trace for the incoming request and stores the trace ID in the context.
+// The trace includes request details that can be used for debugging and monitoring.
+//
+// Parameters:
+//   - ctx: Pointer to the context.Context that will store the trace ID
+//   - req: The incoming Bifrost request to be traced
+//
+// Returns:
+//   - *interfaces.BifrostRequest: The original request, unmodified
+//   - error: Always returns nil as this implementation doesn't produce errors
+//
+// The trace ID format is "YYYYMMDD_HHmmssSSS" based on the current time.
+// If the context is nil, tracing information will still be logged but not stored in context.
 func (plugin *Plugin) PreHook(ctx *context.Context, req *interfaces.BifrostRequest) (*interfaces.BifrostRequest, error) {
 	traceID := time.Now().Format("20060102_150405000")
 
@@ -40,6 +71,20 @@ func (plugin *Plugin) PreHook(ctx *context.Context, req *interfaces.BifrostReque
 	return req, nil
 }
 
+// PostHook is called after a request has been processed by Bifrost.
+// It retrieves the trace ID from the context and logs the response details.
+// This completes the request trace by adding response information.
+//
+// Parameters:
+//   - ctxRef: Pointer to the context.Context containing the trace ID
+//   - res: The Bifrost response to be traced
+//
+// Returns:
+//   - *interfaces.BifrostResponse: The original response, unmodified
+//   - error: Returns an error if the trace ID cannot be retrieved from the context
+//
+// If the context is nil or the trace ID is not found, an error will be returned
+// but the response will still be passed through unmodified.
 func (plugin *Plugin) PostHook(ctxRef *context.Context, res *interfaces.BifrostResponse) (*interfaces.BifrostResponse, error) {
 	// Get traceID from context
 	if ctxRef != nil {
diff --git a/tests/setup.go b/tests/setup.go
index 06e0ee8b28..6a8f640e6e 100644
--- a/tests/setup.go
+++ b/tests/setup.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -13,6 +16,14 @@ import (
 	"github.com/maximhq/maxim-go/logging"
 )
 
+// loadEnv loads environment variables from a .env file into the process environment.
+// It uses the godotenv package to load variables and fails if the .env file cannot be loaded.
+//
+// Environment Variables:
+//   - .env file: Contains configuration values for the test environment
+//
+// Returns:
+//   - None, but will log.Fatal if the .env file cannot be loaded
 func loadEnv() {
 	err := godotenv.Load()
 	if err != nil {
@@ -20,9 +31,28 @@ func loadEnv() {
 	}
 }
 
+// getPlugin initializes and returns a Plugin instance for testing purposes.
+// It sets up the Maxim logger with configuration from environment variables.
+//
+// Environment Variables:
+//   - MAXIM_API_KEY: API key for Maxim SDK authentication
+//   - MAXIM_LOGGER_ID: ID for the Maxim logger instance
+//
+// Returns:
+//   - interfaces.Plugin: A configured plugin instance for request/response tracing
+//   - error: Any error that occurred during plugin initialization
 func getPlugin() (interfaces.Plugin, error) {
 	loadEnv()
 
+	// check if Maxim Logger variables are set
+	if os.Getenv("MAXIM_API_KEY") == "" {
+		return nil, fmt.Errorf("MAXIM_API_KEY is not set, please set it in your .env file or pass nil in the Plugins field when initializing Bifrost")
+	}
+
+	if os.Getenv("MAXIM_LOGGER_ID") == "" {
+		return nil, fmt.Errorf("MAXIM_LOGGER_ID is not set, please set it in your .env file or pass nil in the Plugins field when initializing Bifrost")
+	}
+
 	mx := maxim.Init(&maxim.MaximSDKConfig{ApiKey: os.Getenv("MAXIM_API_KEY")})
 
 	logger, err := mx.GetLogger(&logging.LoggerConfig{Id: os.Getenv("MAXIM_LOGGER_ID")})
@@ -35,10 +65,27 @@ func getPlugin() (interfaces.Plugin, error) {
 	return plugin, nil
 }
 
+// getBifrost initializes and returns a Bifrost instance for testing.
+// It sets up the test account, plugin, and logger configuration.
+//
+// Environment Variables:
+//   - Uses environment variables loaded by loadEnv()
+//
+// Returns:
+//   - *bifrost.Bifrost: A configured Bifrost instance ready for testing
+//   - error: Any error that occurred during Bifrost initialization
+//
+// The function:
+//  1. Loads environment variables
+//  2. Creates a test account instance
+//  3. Initializes a plugin for request tracing
+//  4. Configures Bifrost with the account, plugin, and default logger
 func getBifrost() (*bifrost.Bifrost, error) {
 	loadEnv()
 
 	account := BaseAccount{}
+
+	// You can pass nil in the Plugins field if you don't want to use the implemented example plugin.
 	plugin, err := getPlugin()
 	if err != nil {
 		fmt.Println("Error setting up the plugin:", err)
@@ -48,6 +95,7 @@ func getBifrost() (*bifrost.Bifrost, error) {
 	// Initialize Bifrost
 	b, err := bifrost.Init(interfaces.BifrostConfig{
 		Account: &account,
+		// Plugins: nil,
 		Plugins: []interfaces.Plugin{plugin},
 		Logger:  bifrost.NewDefaultLogger(interfaces.LogLevelInfo),
 	})
diff --git a/tests/tests.go b/tests/tests.go
index 42c7872e6b..a29c6b2d6c 100644
--- a/tests/tests.go
+++ b/tests/tests.go
@@ -1,3 +1,6 @@
+// Package tests provides test utilities and configurations for the Bifrost system.
+// It includes test implementations of interfaces, mock objects, and helper functions
+// for testing the Bifrost functionality with various AI providers.
 package tests
 
 import (
@@ -10,7 +13,20 @@ import (
 	"github.com/maximhq/maxim-go"
 )
 
-// TestConfig holds configuration for test requests
+// TestConfig holds configuration for test requests across different AI providers.
+// It provides a flexible way to configure test scenarios for various provider capabilities.
+//
+// Fields:
+//   - Provider: The AI provider to test (e.g., OpenAI, Anthropic, etc.)
+//   - ChatModel: The model to use for chat completion tests
+//   - TextModel: The model to use for text completion tests
+//   - Messages: Custom messages to use in chat tests (optional)
+//   - SetupText: Whether to run text completion tests
+//   - SetupToolCalls: Whether to run function calling tests
+//   - SetupImage: Whether to run image input tests
+//   - SetupBaseImage: Whether to run base64 image tests
+//   - CustomTextCompletion: Custom text for completion tests (optional)
+//   - CustomParams: Custom model parameters for requests (optional)
 type TestConfig struct {
 	Provider             interfaces.SupportedModelProvider
 	ChatModel            string
@@ -24,14 +40,16 @@ type TestConfig struct {
 	CustomParams         *interfaces.ModelParameters
 }
 
-// Common test messages used across providers
+// CommonTestMessages contains default messages used across providers for testing.
+// These messages are used when no custom messages are provided in the test configuration.
 var CommonTestMessages = []string{
 	"Hello! How are you today?",
 	"Tell me a joke!",
 	"What's your favorite programming language?",
 }
 
-// Common weather tool parameters
+// WeatherToolParams defines the parameters for a weather function tool.
+// This is used to test function calling capabilities of AI providers.
 var WeatherToolParams = interfaces.ModelParameters{
 	Tools: &[]interfaces.Tool{{
 		Type: "function",
@@ -56,7 +74,13 @@ var WeatherToolParams = interfaces.ModelParameters{
 	}},
 }
 
-// setupTextCompletionRequest sets up a text completion request
+// setupTextCompletionRequest sets up and executes a text completion test request.
+// It runs asynchronously and prints the result or error to stdout.
+//
+// Parameters:
+//   - bifrost: The Bifrost instance to use for the request
+//   - config: Test configuration containing model and parameters
+//   - ctx: Context for the request
 func setupTextCompletionRequest(bifrost *bifrost.Bifrost, config TestConfig, ctx context.Context) {
 	text := "Hello world!"
 	if config.CustomTextCompletion != nil {
@@ -84,7 +108,13 @@ func setupTextCompletionRequest(bifrost *bifrost.Bifrost, config TestConfig, ctx
 	}()
 }
 
-// setupChatCompletionRequests sets up multiple chat completion requests
+// setupChatCompletionRequests sets up and executes multiple chat completion test requests.
+// It runs requests asynchronously with staggered delays and prints results to stdout.
+//
+// Parameters:
+//   - bifrost: The Bifrost instance to use for the requests
+//   - config: Test configuration containing model and parameters
+//   - ctx: Context for the requests
 func setupChatCompletionRequests(bifrost *bifrost.Bifrost, config TestConfig, ctx context.Context) {
 	messages := config.Messages
 	if len(messages) == 0 {
@@ -122,7 +152,13 @@ func setupChatCompletionRequests(bifrost *bifrost.Bifrost, config TestConfig, ct
 	}
 }
 
-// setupImageTests sets up image input tests
+// setupImageTests sets up and executes image input test requests.
+// It tests both URL and base64 image inputs (if enabled) and prints results to stdout.
+//
+// Parameters:
+//   - bifrost: The Bifrost instance to use for the requests
+//   - config: Test configuration containing model and parameters
+//   - ctx: Context for the requests
 func setupImageTests(bifrost *bifrost.Bifrost, config TestConfig, ctx context.Context) {
 	params := interfaces.ModelParameters{}
 	if config.CustomParams != nil {
@@ -191,7 +227,13 @@ func setupImageTests(bifrost *bifrost.Bifrost, config TestConfig, ctx context.Co
 	}
 }
 
-// setupToolCalls sets up function calling tests
+// setupToolCalls sets up and executes function calling test requests.
+// It tests the provider's ability to handle tool/function calls and prints results to stdout.
+//
+// Parameters:
+//   - bifrost: The Bifrost instance to use for the requests
+//   - config: Test configuration containing model and parameters
+//   - ctx: Context for the requests
 func setupToolCalls(bifrost *bifrost.Bifrost, config TestConfig, ctx context.Context) {
 	messages := []string{"What's the weather like in Mumbai?"}
 
@@ -240,7 +282,13 @@ func setupToolCalls(bifrost *bifrost.Bifrost, config TestConfig, ctx context.Con
 	}
 }
 
-// setupAllRequests sets up all test requests for a provider
+// SetupAllRequests sets up and executes all configured test requests for a provider.
+// It coordinates the execution of text completion, chat completion, image, and tool call tests
+// based on the provided configuration.
+//
+// Parameters:
+//   - bifrost: The Bifrost instance to use for the requests
+//   - config: Test configuration specifying which tests to run
 func SetupAllRequests(bifrost *bifrost.Bifrost, config TestConfig) {
 	ctx := context.Background()