sync: migrate ai-operator to Gitea (2026-08-10)

internal/ai/fake/provider.go

@@ -0,0 +1,87 @@
+package fake
+
+import (
+	"ai-operator/internal/ai"
+	"ai-operator/internal/media"
+	"context"
+	"sync"
+	"time"
+)
+
+type Provider struct {
+	events      chan ai.VoiceEvent
+	mu          sync.Mutex
+	stats       ai.VoiceProviderStats
+	callID      string
+	toolResults []ai.ToolResult
+	closed      bool
+}
+
+func New() *Provider { return &Provider{events: make(chan ai.VoiceEvent, 16)} }
+func (p *Provider) StartSession(ctx context.Context, cfg ai.VoiceSessionConfig) error {
+	p.mu.Lock()
+	p.events = make(chan ai.VoiceEvent, 16)
+	p.closed = false
+	p.stats = ai.VoiceProviderStats{}
+	now := time.Now().UTC()
+	p.stats.StartedAt = &now
+	p.callID = cfg.CallID
+	p.mu.Unlock()
+	p.emit(ai.VoiceEvent{Type: ai.VoiceEventSessionStarted, CallID: cfg.CallID, At: now})
+	p.emit(ai.VoiceEvent{Type: ai.VoiceEventAssistantTranscriptDelta, CallID: cfg.CallID, Text: "test provider connected", At: now})
+	return nil
+}
+func (p *Provider) SendAudio(ctx context.Context, ch media.AudioChunk) error {
+	p.mu.Lock()
+	p.stats.InputAudioFrames++
+	p.stats.InputAudioBytes += int64(len(ch.Data))
+	p.mu.Unlock()
+	return nil
+}
+func (p *Provider) SendToolResult(ctx context.Context, r ai.ToolResult) error {
+	p.mu.Lock()
+	p.toolResults = append(p.toolResults, r)
+	p.stats.EventsSent++
+	p.mu.Unlock()
+	return nil
+}
+func (p *Provider) Close(ctx context.Context) error {
+	p.mu.Lock()
+	now := time.Now().UTC()
+	p.stats.ClosedAt = &now
+	callID := p.callID
+	p.mu.Unlock()
+	p.emit(ai.VoiceEvent{Type: ai.VoiceEventClosed, CallID: callID, At: now})
+	p.closeEvents()
+	return nil
+}
+func (p *Provider) Events() <-chan ai.VoiceEvent { return p.events }
+func (p *Provider) Stats() ai.VoiceProviderStats { p.mu.Lock(); defer p.mu.Unlock(); return p.stats }
+func (p *Provider) ToolResults() []ai.ToolResult {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	out := make([]ai.ToolResult, len(p.toolResults))
+	copy(out, p.toolResults)
+	return out
+}
+func (p *Provider) EmitForTest(e ai.VoiceEvent) { p.emit(e) }
+func (p *Provider) emit(e ai.VoiceEvent) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.stats.EventsSent++
+	if p.closed {
+		return
+	}
+	select {
+	case p.events <- e:
+	default:
+	}
+}
+func (p *Provider) closeEvents() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if !p.closed {
+		close(p.events)
+		p.closed = true
+	}
+}

internal/ai/fake/provider_test.go

@@ -0,0 +1,39 @@
+package fake
+
+import (
+	"ai-operator/internal/ai"
+	"ai-operator/internal/media"
+	"context"
+	"testing"
+	"time"
+)
+
+func TestFakeProvider(t *testing.T) {
+	p := New()
+	ctx := context.Background()
+	if err := p.StartSession(ctx, ai.VoiceSessionConfig{CallID: "c1"}); err != nil {
+		t.Fatal(err)
+	}
+	if err := p.SendAudio(ctx, media.AudioChunk{CallID: "c1", Data: []byte{0, 0}, Timestamp: time.Now()}); err != nil {
+		t.Fatal(err)
+	}
+	if st := p.Stats(); st.InputAudioFrames != 1 || st.InputAudioBytes != 2 {
+		t.Fatalf("stats=%+v", st)
+	}
+	_ = p.Close(ctx)
+}
+
+func TestFakeProviderCanStartAfterClose(t *testing.T) {
+	p := New()
+	ctx := context.Background()
+	for _, callID := range []string{"c1", "c2"} {
+		if err := p.StartSession(ctx, ai.VoiceSessionConfig{CallID: callID}); err != nil {
+			t.Fatal(err)
+		}
+		if err := p.Close(ctx); err != nil {
+			t.Fatal(err)
+		}
+		for range p.Events() {
+		}
+	}
+}