type GoogleAIProcessor struct {
	client llms.Model
}

func NewGoogleAIProcessor() (*GoogleAIProcessor, error) {
	client, err := googleai.New(context.Background(), googleai.WithAPIKey(config.AppConfig.GoogleAPIKey), googleai.WithHarmThreshold(4))
	if err != nil {
		logger.Log.Errorf("Error initializing Google AI client: %v", err)
		return nil, err
	}
	return &GoogleAIProcessor{
		client: client,
	}, nil
}

func (p *GoogleAIProcessor) ProcessAudio(ctx context.Context, audioData []byte, userID int64) (*models.GenericResponse, error) {
	var err error
	answer, err := p.client.GenerateContent(
		ctx,
		[]llms.MessageContent{
			{
				Role: llms.ChatMessageTypeSystem,
				Parts: []llms.ContentPart{
					llms.TextPart(strings.TrimSpace(SPEECH_TO_TEXT_SYSTEN_PROMPT)),
				},
			},
			{
				Role: llms.ChatMessageTypeHuman,
				Parts: []llms.ContentPart{
					llms.TextPart("I am from Estonia and likely will speak in that language"),
					llms.BinaryPart("audio/wav", audioData),
				},
			},
		},
		llms.WithMaxTokens(4000),
		llms.WithTemperature(0),
		llms.WithModel(config.AppConfig.GoogleVoiceModel),
		llms.WithTools(availableTools),
	)

	if err != nil {

		return nil, err
	}
	logger.Log.Infof("Google AI response received")
	if answer.Choices[0].ToolCalls != nil {
		functionCall := answer.Choices[0].ToolCalls[0].FunctionCall
		switch functionCall.Name {
		case "createNewToDo":
			args := functionCall.Arguments
			logger.Log.Infof("createNewToDo function call with args: %v", args)
			todo, _ := createToDo(args, userID)
			return &models.GenericResponse{
				Type: models.ResponseToDo,
				ToDo: todo,
			}, nil
		case "createReminder":
			args := functionCall.Arguments
			logger.Log.Infof("createReminder function call with args: %v", args)
			reminder, _ := createReminder(args, userID)
			return &models.GenericResponse{
				Type:     models.ResponseReminder,
				Reminder: reminder,
			}, nil
		}
	}
	return &models.GenericResponse{
		Type: models.ResponseText,
		Text: answer.Choices[0].Content,
	}, nil
}


I want to use something like this(dont pay attention to processaudio implementation, it is not relevant atm)
I want to put llm processor into my voice VoiceHandler 

<repo><f p="audio\audio.go"><![CDATA[package audio
import (
 "FUCKYOULANGCHAIN/logger"
 "fmt"
 "os/exec"
)
func ConvertAudio(inputPath, outputPath string) error {
 cmd := exec.Command("ffmpeg", "-i", inputPath, outputPath)
 output, err := cmd.CombinedOutput()
 if err != nil {
 logger.Log.Errorf("FFmpeg conversion error: %v\nOutput: %s", err, string(output))
 return fmt.Errorf("FFmpeg conversion error: %v\nOutput: %s", err, string(output))
 }
 logger.Log.Infof("Audio converted from %s to %s", inputPath, outputPath)
 return nil
}]]></f><f p="config\config.go"><![CDATA[package config
import (
 "FUCKYOULANGCHAIN/logger"
 "os"
 "github.com/joho/godotenv"
 "github.com/kelseyhightower/envconfig"
)
type Config struct {
 TelegramAPIKey string `envconfig:"TELEGRAM_API_KEY" required:"true"`
 TelegramUserID string `envconfig:"TELEGRAM_USER_ID" required:"true"`
 AIProvider string `envconfig:"AI_PROVIDER" default:"googleai" required:"true"`
 OpenAIAPIKey string `envconfig:"OPENAI_API_KEY"`
 OpenAITextModel string `envconfig:"OPENAI_TEXT_MODEL" default:"gpt-3.5-turbo"`
 OpenAIVoiceModel string `envconfig:"OPENAI_VOICE_MODEL" default:"whisper-1"`
 GoogleAPIKey string `envconfig:"GOOGLE_API_KEY"`
 GoogleTextModel string `envconfig:"GOOGLE_TEXT_MODEL" default:"gemini-1.5-flash"`
 GoogleVoiceModel string `envconfig:"GOOGLE_VOICE_MODEL" default:"gemini-1.5-flash"`
}
var AppConfig Config
func LoadConfig() {
 if err := godotenv.Load(); err != nil && !os.IsNotExist(err) {
 logger.Log.Fatalf("Error loading .env file: %v", err)
 }
 err := envconfig.Process("", &AppConfig)
 if err != nil {
 logger.Log.Fatalf("Error loading config: %v", err)
 }
 logger.Log.Info("Configuration loaded successfully")
}]]></f><f p="database\database.go"><![CDATA[package database
import (
 "FUCKYOULANGCHAIN/logger"
 "FUCKYOULANGCHAIN/models"
 "gorm.io/driver/sqlite"
 "gorm.io/gorm"
)
var DB *gorm.DB
func InitDB() {
 var err error
 DB, err = gorm.Open(sqlite.Open("bot.db"), &gorm.Config{})
 if err != nil {
 logger.Log.Fatalf("Failed to connect to database: %v", err)
 }
 err = DB.AutoMigrate(&models.ToDo{}, &models.ToDoItem{}, &models.User{}, &models.Reminder{})
 if err != nil {
 logger.Log.Fatalf("Failed to migrate database schema: %v", err)
 }
 logger.Log.Info("Database initialized successfully")
}]]></f><f p="handler\middleware.go"><![CDATA[package handler
import (
 "FUCKYOULANGCHAIN/config"
 "FUCKYOULANGCHAIN/database"
 "FUCKYOULANGCHAIN/logger"
 "FUCKYOULANGCHAIN/models"
 "FUCKYOULANGCHAIN/state"
 "context"
 "strconv"
 "github.com/go-telegram/bot"
 tgmodels "github.com/go-telegram/bot/models"
)
func VoiceMessageDetect(next bot.HandlerFunc) bot.HandlerFunc {
 return func(ctx context.Context, b *bot.Bot, update *tgmodels.Update) {
 if update.Message.Voice != nil {
 VoiceHandler(ctx, b, update)
 return
 }
 next(ctx, b, update)
 }
}
func RegisterUserMiddleware(next bot.HandlerFunc) bot.HandlerFunc {
 return func(ctx context.Context, b *bot.Bot, update *tgmodels.Update) {
 userID := update.Message.From.ID
 currentState := state.GetUserState(userID)
 if currentState != state.StateNone {
 next(ctx, b, update)
 return
 }
 var user models.User
 result := database.DB.First(&user, userID)
 if result.Error != nil {
 user = models.User{
 ID: userID,
 UserName: update.Message.From.Username,
 }
 database.DB.Create(&user)
 state.SetUserState(userID, state.StateWaitingForTimezone)
 b.SendMessage(ctx, &bot.SendMessageParams{
 ChatID: update.Message.Chat.ID,
 Text: "Please send me your timezone in 'Area/City' format (e.g., 'Europe/London').",
 })
 return
 } else if user.Timezone == "" {
 database.DB.Save(&user)
 state.SetUserState(userID, state.StateWaitingForTimezone)
 b.SendMessage(ctx, &bot.SendMessageParams{
 ChatID: update.Message.Chat.ID,
 Text: "Please send me your timezone in 'Area/City' format (e.g., 'Europe/London').",
 })
 return
 }
 next(ctx, b, update)
 }
}
func OnlyAdminMiddleware(next bot.HandlerFunc) bot.HandlerFunc {
 return func(ctx context.Context, b *bot.Bot, update *tgmodels.Update) {
 userID := update.Message.From.ID
 adminID, _ := strconv.Atoi(config.AppConfig.TelegramUserID)
 if userID != int64(adminID) {
 logger.Log.Warnf("Bot accessed by non-admin: %d", userID)
 return
 }
 next(ctx, b, update)
 }
}]]></f><f p="handler\texthandler.go"><![CDATA[package handler
import (
 "FUCKYOULANGCHAIN/state"
 "context"
 "fmt"
 "github.com/go-telegram/bot"
 "github.com/go-telegram/bot/models"
)
func TextHandler(ctx context.Context, b *bot.Bot, update *models.Update) {
 if update.Message.Text == "" {
 return
 }
 userID := update.Message.From.ID
 currentState := state.GetUserState(userID)
 switch currentState {
 case state.StateNone:
 b.SendMessage(ctx, &bot.SendMessageParams{
 ChatID: update.Message.Chat.ID,
 Text: `
<b>COMMANDS</b> 
/timezone - Update timezone
/newreminder - Create a reminder
/newnote - New note
How can I assist you today?`,
 ParseMode: models.ParseModeHTML,
 })
 case state.StateWaitingForTimezone:
 err := updateTimeZone(userID, update.Message.Text)
 if err != nil {
 b.SendMessage(ctx, &bot.SendMessageParams{
 ChatID: update.Message.Chat.ID,
 Text: fmt.Sprintf("Error: %v\nTry again", err),
 })
 }
 state.ClearUserState(userID)
 b.SendMessage(ctx, &bot.SendMessageParams{
 ChatID: update.Message.Chat.ID,
 Text: "Timezone updated!",
 })
 }
}]]></f><f p="handler\timezone.go"><![CDATA[package handler
import (
 "FUCKYOULANGCHAIN/database"
 "FUCKYOULANGCHAIN/logger"
 "FUCKYOULANGCHAIN/models"
 "errors"
 "fmt"
 "time"
)
func updateTimeZone(userID int64, tz string) error {
 if !validTimezone(tz) {
 return fmt.Errorf("not a valid timezone format")
 }
 result := database.DB.Model(&models.User{}).Where("id = ?", userID).Update("timezone", tz)
 if result.Error != nil {
 logger.Log.Errorf("Failed to update timezone for user %d: %v", userID, result.Error)
 return result.Error
 }
 if result.RowsAffected == 0 {
 return errors.New("no user found with the specified ID")
 }
 logger.Log.Infof("Updated timezone for user %d to %s", userID, tz)
 return nil
}
func validTimezone(tz string) bool {
 _, err := time.LoadLocation(tz)
 return err == nil
}]]></f><f p="handler\voicehandler.go"><![CDATA[package handler
import (
 "FUCKYOULANGCHAIN/state"
 "context"
 "github.com/go-telegram/bot"
 "github.com/go-telegram/bot/models"
)
func VoiceHandler(ctx context.Context, b *bot.Bot, update *models.Update) {
 userID := update.Message.From.ID
 state.SetUserState(userID, state.StateSentVoiceMessage)
 m, _ := b.SendMessage(ctx, &bot.SendMessageParams{
 ChatID: update.Message.Chat.ID,
 Text: "Processing..please wait",
 })
}]]></f><f p="logger\logger.go"><![CDATA[package logger
import (
 "io"
 "os"
 "github.com/sirupsen/logrus"
)
var Log *logrus.Logger
func Init() {
 Log = logrus.New()
 Log.SetOutput(os.Stdout)
 Log.SetLevel(logrus.InfoLevel)
 Log.SetFormatter(&logrus.TextFormatter{
 FullTimestamp: true,
 })
}
func SetOutput(w io.Writer) {
 Log.SetOutput(w)
}]]></f><f p="models\reminder.go"><![CDATA[package models
import "time"
type Reminder struct {
 ID int64 `gorm:"primaryKey" json:"id"`
 UserID int64 `json:"user_id"`
 Message string `json:"message"`
 ReminderTime time.Time `json:"reminder_time"` 
 CreatedAt time.Time `json:"created_at"`
 UpdatedAt time.Time `json:"updated_at"`
}]]></f><f p="models\response.go"><![CDATA[package models
type ResponseType int
const (
 ResponseText ResponseType = iota
 ResponseToDo
 ResponseReminder
 ResponseNote
)
type GenericResponse struct {
 Type ResponseType
 Text string 
 ToDo *ToDo 
 Reminder *Reminder
}]]></f><f p="models\todo.go"><![CDATA[package models
import "time"
type ToDo struct {
 ID int64 `gorm:"primaryKey" json:"id"`
 UserID int64 `json:"user_id"`
 Name string `json:"name"`
 Items []ToDoItem `gorm:"foreignKey:ToDoID" json:"items"`
 CreatedAt time.Time `json:"created_at"`
 UpdatedAt time.Time `json:"updated_at"`
}
type ToDoItem struct {
 ID int64 `gorm:"primaryKey" json:"id"`
 ToDoID int64 `json:"todo_id"`
 Name string `json:"name"`
 Completed bool `json:"completed"`
 CreatedAt time.Time `json:"created_at"`
 UpdatedAt time.Time `json:"updated_at"`
}]]></f><f p="models\user.go"><![CDATA[package models
type User struct {
 ID int64 `gorm:"primaryKey" json:"id"`
 UserName string `json:"username"`
 Timezone string `json:"timezone"`
}]]></f><f p="state\state.go"><![CDATA[package state
import "sync"
type UserState int
const (
 StateNone UserState = iota
 StateWaitingForTimezone
 StateSentVoiceMessage
)
var (
 userStates = make(map[int64]UserState)
 mutex sync.RWMutex
)
func SetUserState(userID int64, state UserState) {
 mutex.Lock()
 defer mutex.Unlock()
 userStates[userID] = state
}
func GetUserState(userID int64) UserState {
 mutex.RLock()
 defer mutex.RUnlock()
 return userStates[userID]
}
func ClearUserState(userID int64) {
 mutex.Lock()
 defer mutex.Unlock()
 delete(userStates, userID)
}]]></f><f p="main.go"><![CDATA[package main
import (
 "FUCKYOULANGCHAIN/config"
 "FUCKYOULANGCHAIN/database"
 "FUCKYOULANGCHAIN/handler"
 "FUCKYOULANGCHAIN/logger"
 "context"
 "os"
 "os/signal"
 "github.com/go-telegram/bot"
)
func init() {
 logger.Init()
 config.LoadConfig()
 database.InitDB()
}
func main() {
 ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
 defer cancel()
 opts := []bot.Option{
 bot.WithMiddlewares(handler.OnlyAdminMiddleware, handler.RegisterUserMiddleware, handler.VoiceMessageDetect),
 }
 b, err := bot.New(config.AppConfig.TelegramAPIKey, opts...)
 if err != nil {
 logger.Log.Fatalf("Failed to create bot: %v", err)
 }
 b.RegisterHandler(bot.HandlerTypeMessageText, "", bot.MatchTypePrefix, handler.TextHandler)
 b.Start(ctx)
}]]></f></repo>