灵隙(synapse) v1.0.0 版本

This commit is contained in:
lychang
2026-06-27 14:08:30 +08:00
parent a73ff857bb
commit 713292489f
44 changed files with 21884 additions and 0 deletions

414
examples/group_demo.go Normal file
View File

@@ -0,0 +1,414 @@
package main
import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
"time"
"synapse/sdk/group"
"synapse/types"
)
// =============================================================================
// Group 群组测试 - 三个 Agent 之间的群组协作
// =============================================================================
func main() {
fmt.Println("=== 灵隙(Synapse)Group 群组测试 ===")
fmt.Println("启动三个 Agent,进行群组协作验证...")
fmt.Println()
// 创建群组客户端(简化版,直接在主程序模拟)
groupClient := &simpleGroupClient{
groups: make(map[string]*group.GroupState),
}
// 启动 Agent 1 (Coordinator) - 监听 9091 端口
go runCoordinatorAgent(groupClient)
// 等待 Agent 1 启动
time.Sleep(1 * time.Second)
// 启动 Agent 2 (Worker1) - 监听 9092 端口
go runWorkerAgent(groupClient, "worker-1", 9092)
// 等待 Agent 2 启动
time.Sleep(1 * time.Second)
// 启动 Agent 3 (Worker2) - 监听 9093 端口
go runWorkerAgent(groupClient, "worker-2", 9093)
// 保持主程序运行
fmt.Println("\n=== Agent 已启动,等待群组测试 ===")
fmt.Println("Agent 1 (Coordinator): http://localhost:9091")
fmt.Println("Agent 2 (Worker-1): http://localhost:9092")
fmt.Println("Agent 3 (Worker-2): http://localhost:9093")
fmt.Println("\n按 Ctrl+C 停止...")
// 自动创建群组并开始测试
go func() {
time.Sleep(2 * time.Second)
createGroup()
}()
select {}
}
// 简化的群组客户端
type simpleGroupClient struct {
groups map[string]*group.GroupState
members map[string][]string // groupID -> agentIDs
}
// 创建群组并开始测试
func createGroup() {
log.Printf("\n=== [主程序] 创建群组 ===")
resp, err := http.Post(
"http://localhost:9091/api/group/create",
"application/json",
jsonBody(map[string]any{}),
)
if err != nil {
log.Printf("[主程序] 创建群组失败: %v", err)
return
}
defer resp.Body.Close()
var result map[string]any
json.NewDecoder(resp.Body).Decode(&result)
log.Printf("[主程序] 创建群组响应: %v", result)
// 等待任务完成
time.Sleep(8 * time.Second)
}
type agentInfo struct {
ID string
Name string
Port int
Handler interface{}
}
// Coordinator Agent(协调者)
func runCoordinatorAgent(client *simpleGroupClient) {
mux := http.NewServeMux()
// 健康检查
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
w.Write([]byte("OK - Coordinator"))
})
// 群组管理 API
mux.HandleFunc("/api/group/create", func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "method not allowed", 405)
return
}
groupID := fmt.Sprintf("group-%d", time.Now().UnixNano())
group := &group.GroupState{
GroupID: groupID,
Name: "视频制作组",
Topology: types.GroupTopologyStar,
Status: types.GroupStatusActive,
Members: []types.GroupMember{
{
AgentID: "coordinator",
AgentName: "协调者",
Role: "coordinator",
JoinedAt: types.NowTimestamp(),
Status: types.GroupMemberActive,
Capabilities: []string{"coordination"},
LoadFactor: 0,
},
{
AgentID: "worker-1",
AgentName: "工作者1",
Role: "worker",
JoinedAt: types.NowTimestamp(),
Status: types.GroupMemberActive,
Capabilities: []string{"video_generation"},
LoadFactor: 0,
},
{
AgentID: "worker-2",
AgentName: "工作者2",
Role: "worker",
JoinedAt: types.NowTimestamp(),
Status: types.GroupMemberActive,
Capabilities: []string{"audio_generation"},
LoadFactor: 0,
},
},
Role: "coordinator",
}
client.groups[groupID] = group
log.Printf("\n=== [Coordinator] 群组创建成功 ===")
log.Printf("Group ID: %s", groupID)
log.Printf("Members: coordinator, worker-1, worker-2")
// 模拟任务拆分
go func() {
time.Sleep(1 * time.Second)
simulateTaskSplit(groupID, client)
}()
// 模拟投票
go func() {
time.Sleep(3 * time.Second)
simulateVote(groupID)
}()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{
"success": true,
"group_id": groupID,
"message": "群组创建成功",
})
})
// 获取群组信息
mux.HandleFunc("/api/group/", func(w http.ResponseWriter, r *http.Request) {
groupID := r.URL.Path[len("/api/group/"):]
group, ok := client.groups[groupID]
if !ok {
http.Error(w, "group not found", 404)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{
"success": true,
"group": group,
})
})
log.Println("[Coordinator] 协调者 Agent 启动,监听端口 9091")
if err := http.ListenAndServe(":9091", mux); err != nil {
log.Fatalf("[Coordinator] Server error: %v", err)
}
}
// Worker Agent(工作者)
func runWorkerAgent(client *simpleGroupClient, workerID string, port int) {
mux := http.NewServeMux()
// 健康检查
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
w.Write([]byte(fmt.Sprintf("OK - %s", workerID)))
})
// 加入群组
mux.HandleFunc("/api/group/join", func(w http.ResponseWriter, r *http.Request) {
var req struct {
GroupID string `json:"group_id"`
}
json.NewDecoder(r.Body).Decode(&req)
log.Printf("\n=== [%s] 申请加入群组 ===", workerID)
log.Printf("Group ID: %s", req.GroupID)
// 模拟处理加入请求
time.Sleep(500 * time.Millisecond)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{
"success": true,
"message": fmt.Sprintf("%s 已加入群组", workerID),
"role": "worker",
"group_id": req.GroupID,
})
})
// 接收任务
mux.HandleFunc("/api/task/subtask", func(w http.ResponseWriter, r *http.Request) {
var req struct {
GroupID string `json:"group_id"`
Subtask string `json:"subtask"`
TaskType string `json:"task_type"`
Payload map[string]interface{} `json:"payload"`
}
json.NewDecoder(r.Body).Decode(&req)
log.Printf("\n=== [%s] 收到子任务 ===", workerID)
log.Printf("Group ID: %s", req.GroupID)
log.Printf("Subtask: %s", req.Subtask)
log.Printf("Task Type: %s", req.TaskType)
log.Printf("Payload: %v", req.Payload)
// 模拟执行任务
go func() {
time.Sleep(1 * time.Second)
log.Printf("[%s] 子任务执行完成: %s", workerID, req.Subtask)
// 发送结果(这里简化处理,只是打印日志)
log.Printf("[%s] 发送子任务结果: %s -> 完成了 %s 的工作", workerID, req.Subtask, req.TaskType)
}()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{
"success": true,
"message": fmt.Sprintf("%s 开始执行任务", workerID),
"subtask": req.Subtask,
"progress": 0,
})
})
// 接收投票
mux.HandleFunc("/api/vote", func(w http.ResponseWriter, r *http.Request) {
var req struct {
GroupID string `json:"group_id"`
VoteID string `json:"vote_id"`
Question string `json:"question"`
Options []string `json:"options"`
}
json.NewDecoder(r.Body).Decode(&req)
log.Printf("\n=== [%s] 收到投票请求 ===", workerID)
log.Printf("Vote ID: %s", req.VoteID)
log.Printf("Question: %s", req.Question)
log.Printf("Options: %v", req.Options)
// 模拟投票决策(选择第一个选项)
selectedOption := req.Options[0]
log.Printf("[%s] 投票: %s", workerID, selectedOption)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]any{
"success": true,
"vote_id": req.VoteID,
"selected_option": selectedOption,
"reason": "看起来更合理",
})
})
log.Printf("[%s] 工作者 Agent 启动,监听端口 %d", workerID, port)
if err := http.ListenAndServe(fmt.Sprintf(":%d", port), mux); err != nil {
log.Fatalf("[%s] Server error: %v", workerID, err)
}
}
// 模拟任务拆分
func simulateTaskSplit(groupID string, client *simpleGroupClient) {
log.Printf("\n=== [Coordinator] 执行任务拆分 ===")
log.Printf("Original Task: 制作视频")
subtasks := []struct {
ID string
Description string
AssignedTo string
}{
{"sub-1", "生成视频脚本", "worker-1"},
{"sub-2", "生成配音", "worker-2"},
}
for _, st := range subtasks {
log.Printf("拆分任务: %s -> %s", st.ID, st.AssignedTo)
// 发送任务给 worker
port := 9092
if st.AssignedTo == "worker-2" {
port = 9093
}
resp, err := http.Post(
fmt.Sprintf("http://localhost:%d/api/task/subtask", port),
"application/json",
jsonBody(map[string]any{
"group_id": groupID,
"subtask": st.ID,
"task_type": "video_generation",
"payload": map[string]any{"description": st.Description},
}),
)
if err != nil {
log.Printf("[Coordinator] 发送任务失败: %v", err)
continue
}
resp.Body.Close()
time.Sleep(500 * time.Millisecond)
}
}
// 模拟投票
func simulateVote(groupID string) {
log.Printf("\n=== [Coordinator] 发起投票 ===")
voteQuestion := "选择视频风格?"
voteOptions := []string{"现代风格", "复古风格", "卡通风格"}
log.Printf("Question: %s", voteQuestion)
log.Printf("Options: %v", voteOptions)
// 收集投票结果
votes := make(map[string]int)
for _, opt := range voteOptions {
votes[opt] = 0
}
// 向两个 worker 发送投票
for _, port := range []int{9092, 9093} {
resp, err := http.Post(
fmt.Sprintf("http://localhost:%d/api/vote", port),
"application/json",
jsonBody(map[string]any{
"group_id": groupID,
"vote_id": fmt.Sprintf("vote-%d", time.Now().UnixNano()),
"question": voteQuestion,
"options": voteOptions,
}),
)
if err != nil {
log.Printf("[Coordinator] 投票请求失败: %v", err)
continue
}
var result map[string]any
json.NewDecoder(resp.Body).Decode(&result)
resp.Body.Close()
if selected, ok := result["selected_option"].(string); ok {
votes[selected]++
}
}
// 统计结果
log.Printf("\n=== [Coordinator] 投票结果 ===")
for opt, count := range votes {
log.Printf("%s: %d 票", opt, count)
}
// 确定获胜者
var winner string
maxVotes := 0
for opt, count := range votes {
if count > maxVotes {
maxVotes = count
winner = opt
}
}
log.Printf("\n最终决定: %s (获得 %d 票)", winner, maxVotes)
// 模拟结果合并
go func() {
time.Sleep(1 * time.Second)
log.Printf("\n=== [Coordinator] 合并任务结果 ===")
log.Printf("所有子任务已完成")
log.Printf("最终结果: 视频制作完成,采用 %s", winner)
}()
}
func jsonBody(v map[string]any) *bytes.Buffer {
data, _ := json.Marshal(v)
return bytes.NewBuffer(data)
}

368
examples/p2p_demo.go Normal file
View File

@@ -0,0 +1,368 @@
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
}