DBT/clawgo
1
0
Fork 0
mirror of https://github.com/YspCoder/clawgo.git synced 2026-04-13 09:13:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix loop

Browse Source
This commit is contained in:
lpf
2026-02-21 11:45:40 +08:00
parent 6724d0e10f
commit cbf7df67d1
6 changed files with 124 additions and 1244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
cmd/clawgo/cmd_gateway.go
View File

@@ -23,7 +23,6 @@ import (
"clawgo/pkg/logger"
"clawgo/pkg/providers"
"clawgo/pkg/sentinel"
"clawgo/pkg/voice"
)
func gatewayCmd() {
@@ -477,34 +476,6 @@ func buildGatewayRuntime(ctx context.Context, cfg *config.Config, msgBus *bus.Me
return nil, nil, fmt.Errorf("create channel manager: %w", err)
}
activeProvider := cfg.Providers.Proxy
if name := strings.TrimSpace(cfg.Agents.Defaults.Proxy); name != "" && name != "proxy" {
if p, ok := cfg.Providers.Proxies[name]; ok {
activeProvider = p
}
}
var transcriber *voice.GroqTranscriber
if activeProvider.APIKey != "" && strings.Contains(activeProvider.APIBase, "groq.com") {
transcriber = voice.NewGroqTranscriber(activeProvider.APIKey)
logger.InfoC("voice", "Groq voice transcription enabled via Proxy config")
}
if transcriber != nil {
if telegramChannel, ok := channelManager.GetChannel("telegram"); ok {
if tc, ok := telegramChannel.(*channels.TelegramChannel); ok {
tc.SetTranscriber(transcriber)
logger.InfoC("voice", "Groq transcription attached to Telegram channel")
}
}
if discordChannel, ok := channelManager.GetChannel("discord"); ok {
if dc, ok := discordChannel.(*channels.DiscordChannel); ok {
dc.SetTranscriber(transcriber)
logger.InfoC("voice", "Groq transcription attached to Discord channel")
}
}
}
return agentLoop, channelManager, nil
}

1078
pkg/agent/loop.go
View File

File diff suppressed because it is too large Load Diff

39
pkg/channels/discord.go
View File

@@ -1,6 +1,9 @@
package channels
import (
"clawgo/pkg/bus"
"clawgo/pkg/config"
"clawgo/pkg/logger"
"context"
"fmt"
"io"
@@ -8,20 +11,14 @@ import (
"os"
"path/filepath"
"strings"
"time"
"clawgo/pkg/bus"
"clawgo/pkg/config"
"clawgo/pkg/logger"
"clawgo/pkg/voice"
"github.com/bwmarrin/discordgo"
)
type DiscordChannel struct {
*BaseChannel
session *discordgo.Session
config config.DiscordConfig
transcriber *voice.GroqTranscriber
session *discordgo.Session
config config.DiscordConfig
}
func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordChannel, error) {
@@ -36,14 +33,9 @@ func NewDiscordChannel(cfg config.DiscordConfig, bus *bus.MessageBus) (*DiscordC
BaseChannel: base,
session: session,
config: cfg,
transcriber: nil,
}, nil
}
func (c *DiscordChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
c.transcriber = transcriber
}
func (c *DiscordChannel) Start(ctx context.Context) error {
logger.InfoC("discord", "Starting Discord bot")
@@ -123,26 +115,7 @@ func (c *DiscordChannel) handleMessage(s *discordgo.Session, m *discordgo.Messag
if localPath != "" {
mediaPaths = append(mediaPaths, localPath)
transcribedText := ""
if c.transcriber != nil && c.transcriber.IsAvailable() {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
result, err := c.transcriber.Transcribe(ctx, localPath)
if err != nil {
logger.WarnCF("discord", "Voice transcription failed", map[string]interface{}{
logger.FieldError: err.Error(),
})
transcribedText = fmt.Sprintf("[audio: %s (transcription failed)]", localPath)
} else {
transcribedText = fmt.Sprintf("[audio transcription: %s]", result.Text)
logger.InfoCF("discord", "Audio transcribed successfully", map[string]interface{}{
"text_preview": truncateString(result.Text, 120),
})
}
} else {
transcribedText = fmt.Sprintf("[audio: %s]", localPath)
}
transcribedText := fmt.Sprintf("[audio: %s]", localPath)
if content != "" {
content += "\n"

31
pkg/channels/telegram.go
View File

@@ -18,7 +18,6 @@ import (
"clawgo/pkg/bus"
"clawgo/pkg/config"
"clawgo/pkg/logger"
"clawgo/pkg/voice"
)
const (
@@ -36,7 +35,6 @@ type TelegramChannel struct {
chatIDsMu sync.RWMutex
updates <-chan telego.Update
runCancel cancelGuard
transcriber *voice.GroqTranscriber
placeholders sync.Map // chatID -> messageID
stopThinking sync.Map // chatID -> chan struct{}
handleSem chan struct{}
@@ -56,7 +54,6 @@ func NewTelegramChannel(cfg config.TelegramConfig, bus *bus.MessageBus) (*Telegr
bot: bot,
config: cfg,
chatIDs: make(map[string]int64),
transcriber: nil,
placeholders: sync.Map{},
stopThinking: sync.Map{},
handleSem: make(chan struct{}, telegramMaxConcurrentHandlers),
@@ -70,10 +67,6 @@ func withTelegramAPITimeout(ctx context.Context) (context.Context, context.Cance
return context.WithTimeout(ctx, telegramAPICallTimeout)
}
func (c *TelegramChannel) SetTranscriber(transcriber *voice.GroqTranscriber) {
c.transcriber = transcriber
}
func (c *TelegramChannel) HealthCheck(ctx context.Context) error {
if !c.IsRunning() {
return fmt.Errorf("telegram bot not running")
@@ -372,32 +365,10 @@ func (c *TelegramChannel) handleMessage(runCtx context.Context, message *telego.
voicePath := c.downloadFile(runCtx, message.Voice.FileID, ".ogg", "")
if voicePath != "" {
mediaPaths = append(mediaPaths, voicePath)
transcribedText := ""
if c.transcriber != nil && c.transcriber.IsAvailable() {
ctx, cancel := context.WithTimeout(runCtx, 30*time.Second)
defer cancel()
result, err := c.transcriber.Transcribe(ctx, voicePath)
if err != nil {
logger.WarnCF("telegram", "Voice transcription failed", map[string]interface{}{
logger.FieldError: err.Error(),
})
transcribedText = fmt.Sprintf("[voice: %s (transcription failed)]", voicePath)
} else {
transcribedText = fmt.Sprintf("[voice transcription: %s]", result.Text)
logger.InfoCF("telegram", "Voice transcribed successfully", map[string]interface{}{
"text_preview": truncateString(result.Text, 120),
})
}
} else {
transcribedText = fmt.Sprintf("[voice: %s]", voicePath)
}
if content != "" {
content += "\n"
}
content += transcribedText
content += fmt.Sprintf("[voice: %s]", voicePath)
}
}

26
pkg/utils/utils.go
View File

@@ -1,26 +0,0 @@
package utils
import (
"encoding/json"
"fmt"
)
// PrettyPrint prints a data structure as a pretty JSON string.
func PrettyPrint(v interface{}) {
b, err := json.MarshalIndent(v, "", " ")
if err != nil {
fmt.Println("error:", err)
}
fmt.Println(string(b))
}
// Truncate returns a truncated version of s with at most maxLen characters.
func Truncate(s string, maxLen int) string {
if len(s) <= maxLen {
return s
}
if maxLen <= 3 {
return s[:maxLen]
}
return s[:maxLen-3] + "..."
}

165
pkg/voice/transcriber.go
View File

@@ -1,165 +0,0 @@
package voice
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
"path/filepath"
"time"
"clawgo/pkg/logger"
)
type GroqTranscriber struct {
apiKey string
apiBase string
httpClient *http.Client
}
type TranscriptionResponse struct {
Text string `json:"text"`
Language string `json:"language,omitempty"`
Duration float64 `json:"duration,omitempty"`
}
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,
apiBase: apiBase,
httpClient: &http.Client{
Timeout: 60 * time.Second,
},
}
}
func (t *GroqTranscriber) Transcribe(ctx context.Context, audioFilePath string) (*TranscriptionResponse, error) {
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, logger.FieldError: 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, logger.FieldError: 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{}{logger.FieldError: err})
return nil, fmt.Errorf("failed to create form file: %w", err)
}
copied, err := io.Copy(part, audioFile)
if err != nil {
logger.ErrorCF("voice", "Failed to copy file content", map[string]interface{}{logger.FieldError: 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{}{logger.FieldError: 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{}{logger.FieldError: 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{}{logger.FieldError: 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{}{logger.FieldError: 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)
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{}{logger.FieldError: 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{}{logger.FieldError: 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{}{logger.FieldError: err})
return nil, fmt.Errorf("failed to unmarshal response: %w", err)
}
logger.InfoCF("voice", "Transcription completed successfully", map[string]interface{}{
logger.FieldTranscriptLength: len(result.Text),
"language": result.Language,
"duration_seconds": result.Duration,
"transcription_preview": truncateText(result.Text, 50),
})
return &result, nil
}
func (t *GroqTranscriber) IsAvailable() bool {
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] + "..."
}