369 lines
10 KiB
Go
369 lines
10 KiB
Go
package main
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"net/http"
|
||
"time"
|
||
|
||
"synapse/sdk/p2p"
|
||
"synapse/types"
|
||
)
|
||
|
||
// =============================================================================
|
||
// P2P 通讯测试 - 两个 Agent 之间的点对点通信
|
||
// =============================================================================
|
||
|
||
func main() {
|
||
fmt.Println("=== 灵隙(Synapse)P2P 通讯测试 ===")
|
||
fmt.Println("启动两个 Agent,进行点对点通讯验证...")
|
||
fmt.Println()
|
||
|
||
// 启动 Agent 1 (Writer Agent) - 监听 8081 端口
|
||
go runAgent1()
|
||
|
||
// 等待 Agent 1 启动
|
||
time.Sleep(1 * time.Second)
|
||
|
||
// 启动 Agent 2 (Caller) - 监听 8082 端口
|
||
go runAgent2()
|
||
|
||
// 保持主程序运行
|
||
fmt.Println("\n=== Agent 已启动,等待通讯测试 ===")
|
||
fmt.Println("Agent 1 (Writer): http://localhost:8081")
|
||
fmt.Println("Agent 2 (Caller): http://localhost:8082")
|
||
fmt.Println("\n按 Ctrl+C 停止...")
|
||
|
||
select {}
|
||
}
|
||
|
||
// Agent 1 - Writer Agent(任务执行方)
|
||
func runAgent1() {
|
||
// 创建 P2P 客户端
|
||
client, err := p2p.NewClient(&p2p.ClientConfig{
|
||
AgentEndpoint: types.AgentEndpoint{
|
||
AgentID: "writer-agent",
|
||
AgentName: "作家 Agent",
|
||
SystemID: "test-system",
|
||
Endpoint: "http://localhost:8081/callback",
|
||
},
|
||
AuthSecret: "secret-123",
|
||
CallbackPort: 8081,
|
||
})
|
||
if err != nil {
|
||
log.Fatalf("Failed to create Agent 1: %v", err)
|
||
}
|
||
|
||
// 设置消息处理器
|
||
client.SetMessageHandler(&writerHandler{})
|
||
|
||
// 启动 HTTP 服务处理回调
|
||
mux := http.NewServeMux()
|
||
mux.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {
|
||
var msg types.UnifiedSynapseMessage
|
||
if err := json.NewDecoder(r.Body).Decode(&msg); err != nil {
|
||
http.Error(w, "bad request", 400)
|
||
return
|
||
}
|
||
|
||
resp, err := client.HandleMessage(r.Context(), &msg)
|
||
if err != nil {
|
||
log.Printf("[Agent1] Error handling message: %v", err)
|
||
http.Error(w, "internal error", 500)
|
||
return
|
||
}
|
||
|
||
if resp != nil {
|
||
respBytes, _ := json.Marshal(resp)
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Write(respBytes)
|
||
}
|
||
})
|
||
|
||
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
|
||
w.WriteHeader(200)
|
||
w.Write([]byte("OK"))
|
||
})
|
||
|
||
log.Println("[Agent1] Writer Agent 启动,监听端口 8081")
|
||
if err := http.ListenAndServe(":8081", mux); err != nil {
|
||
log.Fatalf("[Agent1] Server error: %v", err)
|
||
}
|
||
}
|
||
|
||
// Agent 2 - Caller Agent(任务请求方)
|
||
func runAgent2() {
|
||
// 创建 P2P 客户端
|
||
client, err := p2p.NewClient(&p2p.ClientConfig{
|
||
AgentEndpoint: types.AgentEndpoint{
|
||
AgentID: "caller-agent",
|
||
AgentName: "调用方 Agent",
|
||
SystemID: "test-system",
|
||
Endpoint: "http://localhost:8082/callback",
|
||
},
|
||
AuthSecret: "secret-123",
|
||
CallbackPort: 8082,
|
||
})
|
||
if err != nil {
|
||
log.Fatalf("Failed to create Agent 2: %v", err)
|
||
}
|
||
|
||
// 设置消息处理器
|
||
client.SetMessageHandler(&callerHandler{})
|
||
|
||
// 启动 HTTP 服务
|
||
mux := http.NewServeMux()
|
||
mux.HandleFunc("/callback", func(w http.ResponseWriter, r *http.Request) {
|
||
var msg types.UnifiedSynapseMessage
|
||
if err := json.NewDecoder(r.Body).Decode(&msg); err != nil {
|
||
http.Error(w, "bad request", 400)
|
||
return
|
||
}
|
||
|
||
resp, err := client.HandleMessage(r.Context(), &msg)
|
||
if err != nil {
|
||
log.Printf("[Agent2] Error handling message: %v", err)
|
||
http.Error(w, "internal error", 500)
|
||
return
|
||
}
|
||
|
||
if resp != nil {
|
||
respBytes, _ := json.Marshal(resp)
|
||
w.Header().Set("Content-Type", "application/json")
|
||
w.Write(respBytes)
|
||
}
|
||
})
|
||
|
||
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
|
||
w.WriteHeader(200)
|
||
w.Write([]byte("OK"))
|
||
})
|
||
|
||
// 启动后发送测试任务
|
||
go func() {
|
||
time.Sleep(2 * time.Second)
|
||
sendTestTask(client)
|
||
}()
|
||
|
||
log.Println("[Agent2] Caller Agent 启动,监听端口 8082")
|
||
if err := http.ListenAndServe(":8082", mux); err != nil {
|
||
log.Fatalf("[Agent2] Server error: %v", err)
|
||
}
|
||
}
|
||
|
||
// Writer Agent 的消息处理器
|
||
type writerHandler struct{}
|
||
|
||
func (h *writerHandler) HandleTaskRequest(ctx context.Context, msg *types.UnifiedSynapseMessage) (*types.UnifiedSynapseMessage, error) {
|
||
var payload types.TaskRequestPayload
|
||
if err := json.Unmarshal(msg.Payload, &payload); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
log.Printf("\n=== [Agent1] 收到任务请求 ===")
|
||
log.Printf("Task ID: %s", payload.Task.ID)
|
||
log.Printf("Task Type: %s", payload.Task.Type)
|
||
log.Printf("Payload: %v", payload.Task.Payload)
|
||
|
||
// 发送任务确认
|
||
confirmPayload, _ := json.Marshal(types.TaskConfirmPayload{
|
||
TaskID: payload.Task.ID,
|
||
Confirmed: true,
|
||
EstimatedDuration: 5,
|
||
ExpectedCompletion: types.Timestamp(time.Now().Add(5 * time.Second).Format(time.RFC3339)),
|
||
CapabilitiesUsed: []string{"text_generation"},
|
||
})
|
||
|
||
confirmMsg := &types.UnifiedSynapseMessage{
|
||
ID: types.GenerateMessageID(),
|
||
Version: "1.0.0",
|
||
Type: string(types.P2PTaskConfirm),
|
||
Sender: *msg.Receiver,
|
||
Receiver: &msg.Sender,
|
||
Payload: confirmPayload,
|
||
Timestamp: types.NowTimestamp(),
|
||
}
|
||
|
||
log.Printf("[Agent1] 发送任务确认: %s\n", payload.Task.ID)
|
||
|
||
// 模拟处理,然后发送完成消息
|
||
go func() {
|
||
time.Sleep(1 * time.Second)
|
||
|
||
// 发送进度更新
|
||
progressPayload, _ := json.Marshal(types.TaskStatusUpdatePayload{
|
||
TaskID: payload.Task.ID,
|
||
Status: "executing",
|
||
Progress: 50,
|
||
Message: "正在生成文本...",
|
||
})
|
||
|
||
progressMsg := &types.UnifiedSynapseMessage{
|
||
ID: types.GenerateMessageID(),
|
||
Version: "1.0.0",
|
||
Type: string(types.P2PTaskStatusUpdate),
|
||
Sender: *msg.Receiver,
|
||
Receiver: &msg.Sender,
|
||
Payload: progressPayload,
|
||
Timestamp: types.NowTimestamp(),
|
||
}
|
||
|
||
log.Printf("[Agent1] 发送进度更新: 50%%")
|
||
_ = sendMessage(progressMsg)
|
||
|
||
time.Sleep(1 * time.Second)
|
||
|
||
// 发送完成消息
|
||
result := fmt.Sprintf("生成了一个关于「%v」的故事", payload.Task.Payload["topic"])
|
||
completePayload, _ := json.Marshal(types.TaskCompletePayload{
|
||
TaskID: payload.Task.ID,
|
||
Result: struct {
|
||
OutputType string `json:"output_type"`
|
||
Output any `json:"output"`
|
||
Metadata map[string]interface{} `json:"metadata,omitempty"`
|
||
}{
|
||
OutputType: "text",
|
||
Output: result,
|
||
Metadata: map[string]interface{}{"tokens": len(result)},
|
||
},
|
||
Summary: "任务已完成",
|
||
})
|
||
|
||
completeMsg := &types.UnifiedSynapseMessage{
|
||
ID: types.GenerateMessageID(),
|
||
Version: "1.0.0",
|
||
Type: string(types.P2PTaskComplete),
|
||
Sender: *msg.Receiver,
|
||
Receiver: &msg.Sender,
|
||
Payload: completePayload,
|
||
Timestamp: types.NowTimestamp(),
|
||
}
|
||
|
||
log.Printf("[Agent1] 发送任务完成: %s\n", result)
|
||
_ = sendMessage(completeMsg)
|
||
}()
|
||
|
||
return confirmMsg, nil
|
||
}
|
||
|
||
func (h *writerHandler) HandleTaskStatusUpdate(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
log.Printf("[Agent1] 收到状态更新: %s", msg.Type)
|
||
return nil
|
||
}
|
||
|
||
func (h *writerHandler) HandleTaskComplete(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskCompletePayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("[Agent1] 任务完成: %s", payload.Summary)
|
||
return nil
|
||
}
|
||
|
||
func (h *writerHandler) HandleTaskFailed(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskFailedPayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("[Agent1] 任务失败: %s", payload.Error.Message)
|
||
return nil
|
||
}
|
||
|
||
func (h *writerHandler) HandleNeedHuman(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskNeedHumanPayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("[Agent1] 需要人类介入: %s", payload.Reason.Message)
|
||
return nil
|
||
}
|
||
|
||
// Caller Agent 的消息处理器
|
||
type callerHandler struct{}
|
||
|
||
func (h *callerHandler) HandleTaskRequest(ctx context.Context, msg *types.UnifiedSynapseMessage) (*types.UnifiedSynapseMessage, error) {
|
||
log.Printf("[Agent2] 收到任务请求")
|
||
return nil, nil
|
||
}
|
||
|
||
func (h *callerHandler) HandleTaskStatusUpdate(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskStatusUpdatePayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("\n=== [Agent2] 收到状态更新 ===")
|
||
log.Printf("Task ID: %s", payload.TaskID)
|
||
log.Printf("Status: %s", payload.Status)
|
||
log.Printf("Progress: %d%%", payload.Progress)
|
||
log.Printf("Message: %s\n", payload.Message)
|
||
return nil
|
||
}
|
||
|
||
func (h *callerHandler) HandleTaskComplete(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskCompletePayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("\n=== [Agent2] 收到任务完成 ===")
|
||
log.Printf("Task ID: %s", payload.TaskID)
|
||
log.Printf("Result: %v", payload.Result.Output)
|
||
log.Printf("Summary: %s\n", payload.Summary)
|
||
return nil
|
||
}
|
||
|
||
func (h *callerHandler) HandleTaskFailed(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskFailedPayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("\n=== [Agent2] 收到任务失败 ===")
|
||
log.Printf("Task ID: %s", payload.TaskID)
|
||
log.Printf("Error: %s\n", payload.Error.Message)
|
||
return nil
|
||
}
|
||
|
||
func (h *callerHandler) HandleNeedHuman(ctx context.Context, msg *types.UnifiedSynapseMessage) error {
|
||
var payload types.TaskNeedHumanPayload
|
||
json.Unmarshal(msg.Payload, &payload)
|
||
log.Printf("\n=== [Agent2] 收到人工介入请求 ===")
|
||
log.Printf("Task ID: %s", payload.TaskID)
|
||
log.Printf("Reason: %s\n", payload.Reason.Message)
|
||
return nil
|
||
}
|
||
|
||
// 发送测试任务
|
||
func sendTestTask(client *p2p.Client) {
|
||
log.Println("\n=== [Agent2] 发送测试任务 ===")
|
||
|
||
target := types.AgentEndpoint{
|
||
AgentID: "writer-agent",
|
||
AgentName: "作家 Agent",
|
||
SystemID: "test-system",
|
||
Endpoint: "http://localhost:8081/callback",
|
||
}
|
||
|
||
taskID, err := client.SendTaskRequest(context.Background(), target, "text_generation", map[string]any{
|
||
"topic": "春天",
|
||
"style": "古诗",
|
||
"length": "short",
|
||
})
|
||
if err != nil {
|
||
log.Printf("[Agent2] 发送任务失败: %v", err)
|
||
return
|
||
}
|
||
|
||
log.Printf("[Agent2] 任务已发送,Task ID: %s", taskID)
|
||
|
||
// 等待任务完成
|
||
state, err := client.WaitForTask(context.Background(), taskID, 30*time.Second)
|
||
if err != nil {
|
||
log.Printf("[Agent2] 等待任务失败: %v", err)
|
||
return
|
||
}
|
||
|
||
log.Printf("\n=== [测试结果] ===")
|
||
log.Printf("最终状态: %s", state.Status)
|
||
log.Printf("结果: %v", state.Result)
|
||
}
|
||
|
||
func sendMessage(msg *types.UnifiedSynapseMessage) error {
|
||
body, _ := json.Marshal(msg)
|
||
resp, err := http.Post(msg.Receiver.Endpoint, "application/json", bytes.NewReader(body))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
resp.Body.Close()
|
||
return nil
|
||
}
|