chore: initialize go-sip repository

2026-09-21 08:56:04 +08:00
commit 643b11b21f
309 changed files with 40521 additions and 0 deletions
@@ -0,0 +1,187 @@
+package callflow
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"git.ipao.vip/rogee/go-sip/contracts"
+	"git.ipao.vip/rogee/go-sip/internal/ai"
+	"git.ipao.vip/rogee/go-sip/internal/media"
+)
+
+func TestInitialMediaWaitIsBounded(t *testing.T) {
+	raw, err := contracts.Read("examples/agent-version-full-explicit.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot, err := ai.ValidateForMode(raw, ai.ModeFullAI)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Execute(context.Background(), NewMemorySession(nil), ai.MockPipeline{}, snapshot, "测试开场", time.Millisecond)
+	if err == nil {
+		t.Fatal("expected bounded initial media wait to fail")
+	}
+}
+
+func TestSharedFlowRunsThreeConversationTurns(t *testing.T) {
+	raw, err := contracts.Read("examples/agent-version-full-explicit.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot, err := ai.ValidateForMode(raw, ai.ModeFullAI)
+	if err != nil {
+		t.Fatal(err)
+	}
+	session := &scriptedTurnSession{turns: [][]byte{make([]byte, 6400), make([]byte, 6400), make([]byte, 6400)}}
+	result, err := ExecuteWithCapture(context.Background(), session, ai.MockPipeline{MaxAudioBytes: 16 << 20}, snapshot, "测试开场", CaptureConfig{
+		FirstSpeechTimeout: time.Second,
+		MaxDuration:        2 * time.Millisecond,
+		MaxTurns:           3,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(result.Turns) != 3 || len(result.InboundTurns) != 3 || len(result.OutboundTurns) != 4 {
+		t.Fatalf("expected opening plus three shared turns, got turns=%d inbound=%d outbound=%d", len(result.Turns), len(result.InboundTurns), len(result.OutboundTurns))
+	}
+	if result.Turn.Transcript == "" || result.Turn.Reply == "" || result.RTP.ReceivedBytes != 19200 {
+		t.Fatalf("three-turn flow facts are incomplete: %+v", result)
+	}
+}
+
+type scriptedTurnSession struct {
+	turns  [][]byte
+	index  int
+	served bool
+	stats  media.RTPStats
+}
+
+func (s *scriptedTurnSession) ReadPayload(ctx context.Context) ([]byte, error) {
+	if !s.served && s.index < len(s.turns) {
+		s.served = true
+		payload := append([]byte(nil), s.turns[s.index]...)
+		s.index++
+		s.stats.ReceivedPackets++
+		s.stats.ReceivedBytes += uint64(len(payload))
+		return payload, nil
+	}
+	<-ctx.Done()
+	s.served = false
+	return nil, ctx.Err()
+}
+
+func (s *scriptedTurnSession) SendPCM16(ctx context.Context, pcm []byte, _ int) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	s.stats.SentPackets++
+	s.stats.SentBytes += uint64(len(pcm))
+	return nil
+}
+
+func (s *scriptedTurnSession) Stats() media.RTPStats { return s.stats }
+
+type invalidCallPipeline struct{}
+
+func (invalidCallPipeline) Synthesize(context.Context, ai.Snapshot, string) ([]byte, error) {
+	return make([]byte, 6400), nil
+}
+
+func (invalidCallPipeline) RunTurn(context.Context, ai.Snapshot, []byte) (ai.TurnResult, error) {
+	return ai.TurnResult{Transcript: "打错了", Reply: ai.InvalidCallMarker, AudioPCM16: make([]byte, 6400)}, nil
+}
+
+func TestInvalidCallStopsBeforeReply(t *testing.T) {
+	raw, err := contracts.Read("examples/agent-version-full-explicit.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot, err := ai.ValidateForMode(raw, ai.ModeFullAI)
+	if err != nil {
+		t.Fatal(err)
+	}
+	session := &scriptedTurnSession{turns: [][]byte{make([]byte, 6400)}}
+	result, err := ExecuteWithCapture(context.Background(), session, invalidCallPipeline{}, snapshot, "开场", CaptureConfig{
+		FirstSpeechTimeout: time.Second,
+		MaxDuration:        2 * time.Millisecond,
+		MaxTurns:           3,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Turn.InvalidCall || result.Turn.InvalidReason != "llm_invalid_call_marker" || len(result.Turns) != 1 {
+		t.Fatalf("invalid call was not classified: %+v", result)
+	}
+	if session.stats.SentPackets != 1 {
+		t.Fatalf("invalid call must not send a reply, sent packets=%d", session.stats.SentPackets)
+	}
+}
+
+func TestASROnlySkipsOpeningLLMAndTTS(t *testing.T) {
+	raw, err := contracts.Read("examples/agent-version-asr-only.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot, err := ai.ValidateForMode(raw, ai.ModeASROnly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pipeline := &asrOnlyPipeline{}
+	session := &scriptedTurnSession{turns: [][]byte{make([]byte, 6400)}}
+	result, err := ExecuteWithCapture(context.Background(), session, pipeline, snapshot, "不得播放", CaptureConfig{
+		FirstSpeechTimeout: time.Second,
+		MaxDuration:        time.Millisecond,
+		MaxTurns:           1,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if pipeline.synthesizeCalls != 0 || pipeline.turnCalls != 1 {
+		t.Fatalf("ASR-only provider calls = synthesize:%d turn:%d", pipeline.synthesizeCalls, pipeline.turnCalls)
+	}
+	if result.Turn.Transcript != "asr-only transcript" || result.Turn.Reply != "" || len(result.OutboundTurns) != 0 {
+		t.Fatalf("unexpected ASR-only result: %+v", result)
+	}
+	if session.stats.SentPackets != 0 {
+		t.Fatalf("ASR-only flow must not send opening/reply audio, sent packets=%d", session.stats.SentPackets)
+	}
+}
+
+type asrOnlyPipeline struct {
+	synthesizeCalls int
+	turnCalls       int
+}
+
+func (p *asrOnlyPipeline) Synthesize(context.Context, ai.Snapshot, string) ([]byte, error) {
+	p.synthesizeCalls++
+	return nil, nil
+}
+
+func (p *asrOnlyPipeline) RunTurn(context.Context, ai.Snapshot, []byte) (ai.TurnResult, error) {
+	p.turnCalls++
+	return ai.TurnResult{Transcript: "asr-only transcript"}, nil
+}
+
+func TestMockModeUsesTheSharedConversationFlow(t *testing.T) {
+	raw, err := contracts.Read("examples/agent-version-full-explicit.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot, err := ai.ValidateForMode(raw, ai.ModeFullAI)
+	if err != nil {
+		t.Fatal(err)
+	}
+	session := NewMemorySession(make([]byte, 6400))
+	result, err := Execute(context.Background(), session, ai.MockPipeline{MaxAudioBytes: 16 << 20}, snapshot, "测试开场", 10*time.Millisecond)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Turn.Transcript == "" || result.Turn.Reply == "" || len(result.Turn.AudioPCM16) == 0 {
+		t.Fatalf("shared flow did not complete mock ASR/LLM/TTS: %+v", result.Turn)
+	}
+	if result.RTP.ReceivedBytes != 6400 || result.RTP.SentPackets == 0 || len(session.OutboundPCM()) == 0 {
+		t.Fatalf("shared media boundary was not exercised: %+v", result.RTP)
+	}
+}