* Discord & Telegram support ASR through groq

pkg/voice/transcriber.go

@@ -6,12 +6,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"mime/multipart"
 	"net/http"
 	"os"
 	"path/filepath"
 	"time"
+
+	"github.com/sipeed/picoclaw/pkg/logger"
 )
 
 type GroqTranscriber struct {
@@ -27,6 +28,8 @@ type TranscriptionResponse struct {
 }
 
 func NewGroqTranscriber(apiKey string) *GroqTranscriber {
+	logger.DebugCF("voice", "Creating Groq transcriber", map[string]interface{}{"has_api_key": apiKey != ""})
+
 	apiBase := "https://api.groq.com/openai/v1"
 	return &GroqTranscriber{
 		apiKey:  apiKey,
@@ -38,79 +41,125 @@ func NewGroqTranscriber(apiKey string) *GroqTranscriber {
 }
 
 func (t *GroqTranscriber) Transcribe(ctx context.Context, audioFilePath string) (*TranscriptionResponse, error) {
-	log.Printf("Starting transcription for audio file: %s", audioFilePath)
+	logger.InfoCF("voice", "Starting transcription", map[string]interface{}{"audio_file": audioFilePath})
 
 	audioFile, err := os.Open(audioFilePath)
 	if err != nil {
+		logger.ErrorCF("voice", "Failed to open audio file", map[string]interface{}{"path": audioFilePath, "error": err})
 		return nil, fmt.Errorf("failed to open audio file: %w", err)
 	}
 	defer audioFile.Close()
 
 	fileInfo, err := audioFile.Stat()
 	if err != nil {
+		logger.ErrorCF("voice", "Failed to get file info", map[string]interface{}{"path": audioFilePath, "error": err})
 		return nil, fmt.Errorf("failed to get file info: %w", err)
 	}
 
+	logger.DebugCF("voice", "Audio file details", map[string]interface{}{
+		"size_bytes": fileInfo.Size(),
+		"file_name":  filepath.Base(audioFilePath),
+	})
+
 	var requestBody bytes.Buffer
 	writer := multipart.NewWriter(&requestBody)
 
 	part, err := writer.CreateFormFile("file", filepath.Base(audioFilePath))
 	if err != nil {
+		logger.ErrorCF("voice", "Failed to create form file", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to create form file: %w", err)
 	}
 
-	if _, err := io.Copy(part, audioFile); err != nil {
+	copied, err := io.Copy(part, audioFile)
+	if err != nil {
+		logger.ErrorCF("voice", "Failed to copy file content", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to copy file content: %w", err)
 	}
 
+	logger.DebugCF("voice", "File copied to request", map[string]interface{}{"bytes_copied": copied})
+
 	if err := writer.WriteField("model", "whisper-large-v3"); err != nil {
+		logger.ErrorCF("voice", "Failed to write model field", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to write model field: %w", err)
 	}
 
 	if err := writer.WriteField("response_format", "json"); err != nil {
+		logger.ErrorCF("voice", "Failed to write response_format field", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to write response_format field: %w", err)
 	}
 
 	if err := writer.Close(); err != nil {
+		logger.ErrorCF("voice", "Failed to close multipart writer", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to close multipart writer: %w", err)
 	}
 
 	url := t.apiBase + "/audio/transcriptions"
 	req, err := http.NewRequestWithContext(ctx, "POST", url, &requestBody)
 	if err != nil {
+		logger.ErrorCF("voice", "Failed to create request", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
 	req.Header.Set("Content-Type", writer.FormDataContentType())
 	req.Header.Set("Authorization", "Bearer "+t.apiKey)
 
-	log.Printf("Sending transcription request to Groq API (file size: %d bytes)", fileInfo.Size())
+	logger.DebugCF("voice", "Sending transcription request to Groq API", map[string]interface{}{
+		"url":                url,
+		"request_size_bytes": requestBody.Len(),
+		"file_size_bytes":    fileInfo.Size(),
+	})
 
 	resp, err := t.httpClient.Do(req)
 	if err != nil {
+		logger.ErrorCF("voice", "Failed to send request", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
+		logger.ErrorCF("voice", "Failed to read response", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to read response: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
+		logger.ErrorCF("voice", "API error", map[string]interface{}{
+			"status_code": resp.StatusCode,
+			"response":    string(body),
+		})
 		return nil, fmt.Errorf("API error (status %d): %s", resp.StatusCode, string(body))
 	}
 
+	logger.DebugCF("voice", "Received response from Groq API", map[string]interface{}{
+		"status_code":         resp.StatusCode,
+		"response_size_bytes": len(body),
+	})
+
 	var result TranscriptionResponse
 	if err := json.Unmarshal(body, &result); err != nil {
+		logger.ErrorCF("voice", "Failed to unmarshal response", map[string]interface{}{"error": err})
 		return nil, fmt.Errorf("failed to unmarshal response: %w", err)
 	}
 
-	log.Printf("Transcription completed successfully (text length: %d chars)", len(result.Text))
+	logger.InfoCF("voice", "Transcription completed successfully", map[string]interface{}{
+		"text_length":           len(result.Text),
+		"language":              result.Language,
+		"duration_seconds":      result.Duration,
+		"transcription_preview": truncateText(result.Text, 50),
+	})
 
 	return &result, nil
 }
 
 func (t *GroqTranscriber) IsAvailable() bool {
-	return t.apiKey != ""
+	available := t.apiKey != ""
+	logger.DebugCF("voice", "Checking transcriber availability", map[string]interface{}{"available": available})
+	return available
+}
+
+func truncateText(text string, maxLen int) string {
+	if len(text) <= maxLen {
+		return text
+	}
+	return text[:maxLen] + "..."
 }