mirror of
https://gitcode.com/JianFeeeee/HomeAgent.git
synced 2026-09-21 17:38:10 +00:00
7f28b997e6
- Output channels generate per-channel tools: output_send__{name} (type=output) + output_send__{name}_help
- content is JSON string transparently passed to plugin handler for routing
- EventAgentLLMChain: full LLM response forwarded after each turn for webui/logs
- sdk.New refactored to SDKConfig struct (no more 13 positional args)
- RegisterOutputChannel adds desc param for JSON format documentation
- channelDevice simplified (no Tools method), desc field added
- Child agent permission updated for output_send__ prefix
- System prompt: output gates, multi-call, long messages split
- WebUI: subscribes to EventAgentLLMChain in SSE, no output channel
- Tests updated for new naming convention
84 lines
1.7 KiB
Go
84 lines
1.7 KiB
Go
package events
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"sync"
|
|
)
|
|
|
|
type EventType string
|
|
|
|
const (
|
|
EventRawInput EventType = "raw_input"
|
|
EventAgentOutput EventType = "agent_output"
|
|
EventAgentLLMChain EventType = "agent_llm_chain"
|
|
EventToolCall EventType = "tool_call"
|
|
EventReasoning EventType = "reasoning"
|
|
EventStage EventType = "stage"
|
|
EventSystem EventType = "system"
|
|
EventAll EventType = "*"
|
|
)
|
|
|
|
type Event struct {
|
|
Type EventType `json:"type"`
|
|
Source string `json:"source"`
|
|
Payload map[string]interface{} `json:"payload"`
|
|
Timestamp int64 `json:"timestamp"`
|
|
}
|
|
|
|
type Handler func(event *Event)
|
|
|
|
type Bus struct {
|
|
mu sync.RWMutex
|
|
subs map[EventType][]Handler
|
|
}
|
|
|
|
func NewBus() *Bus {
|
|
return &Bus{
|
|
subs: make(map[EventType][]Handler),
|
|
}
|
|
}
|
|
|
|
func (b *Bus) Publish(evt *Event) {
|
|
b.mu.RLock()
|
|
allHandlers := make([]Handler, len(b.subs[EventAll]))
|
|
copy(allHandlers, b.subs[EventAll])
|
|
typeHandlers := make([]Handler, len(b.subs[evt.Type]))
|
|
copy(typeHandlers, b.subs[evt.Type])
|
|
b.mu.RUnlock()
|
|
|
|
for _, h := range allHandlers {
|
|
b.safeCall(h, evt)
|
|
}
|
|
for _, h := range typeHandlers {
|
|
b.safeCall(h, evt)
|
|
}
|
|
}
|
|
|
|
func (b *Bus) safeCall(h Handler, evt *Event) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
log.Printf("[bus] handler panic: %v", r)
|
|
}
|
|
}()
|
|
h(evt)
|
|
}
|
|
|
|
func (b *Bus) Subscribe(eventType EventType, handler Handler) func() {
|
|
b.mu.Lock()
|
|
b.subs[eventType] = append(b.subs[eventType], handler)
|
|
b.mu.Unlock()
|
|
|
|
return func() {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
list := b.subs[eventType]
|
|
for i, h := range list {
|
|
if fmt.Sprintf("%p", h) == fmt.Sprintf("%p", handler) {
|
|
b.subs[eventType] = append(list[:i], list[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|