From 06fad9571959df0d908c8a7dc48d70b3c39a3326 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 19:08:46 +0600 Subject: [PATCH 01/53] feat(agent): add network error retry with configurable max retries and backoff - Add isNetworkError detection for connection reset, broken pipe, read/write tcp, EOF - Add retry logic with configurable exponential backoff for network errors - Add config options max_llm_retries and llm_retry_backoff_secs in agents.defaults - Network errors now retry with backoff (was previously not retried) - Timeout errors now use configurable backoff instead of hardcoded 5s - Default: 2 retries with 2s backoff (3 total attempts) --- pkg/agent/pipeline_llm.go | 49 +++++++++++++++++++++++++++++++++++++-- pkg/config/config.go | 2 ++ 2 files changed, 49 insertions(+), 2 deletions(-) diff --git a/pkg/agent/pipeline_llm.go b/pkg/agent/pipeline_llm.go index c426c25c9..95535ed9b 100644 --- a/pkg/agent/pipeline_llm.go +++ b/pkg/agent/pipeline_llm.go @@ -185,7 +185,14 @@ func (p *Pipeline) CallLLM( // Retry loop var err error - maxRetries := 2 + maxRetries := p.Cfg.Agents.Defaults.MaxLLMRetries + if maxRetries <= 0 { + maxRetries = 2 + } + backoffSecs := p.Cfg.Agents.Defaults.LLMRetryBackoffSecs + if backoffSecs <= 0 { + backoffSecs = 2 + } for retry := 0; retry <= maxRetries; retry++ { exec.response, err = callLLM(exec.callMessages, exec.providerToolDefs) if err == nil { @@ -233,6 +240,15 @@ func (p *Pipeline) CallLLM( strings.Contains(errMsg, "timed out") || strings.Contains(errMsg, "timeout exceeded") + isNetworkError := !isTimeoutError && (strings.Contains(errMsg, "connection reset") || + strings.Contains(errMsg, "connection refused") || + strings.Contains(errMsg, "broken pipe") || + strings.Contains(errMsg, "no such host") || + strings.Contains(errMsg, "network is unreachable") || + strings.Contains(errMsg, "read tcp") || + strings.Contains(errMsg, "write tcp") || + strings.Contains(errMsg, "eof")) + isContextError := !isTimeoutError && (strings.Contains(errMsg, "context_length_exceeded") || strings.Contains(errMsg, "context window") || strings.Contains(errMsg, "context_window") || @@ -245,7 +261,7 @@ func (p *Pipeline) CallLLM( strings.Contains(errMsg, "request too large")) if isTimeoutError && retry < maxRetries { - backoff := time.Duration(retry+1) * 5 * time.Second + backoff := time.Duration(retry+1) * time.Duration(backoffSecs) * time.Second al.emitEvent( EventKindLLMRetry, ts.eventMeta("runTurn", "turn.llm.retry"), @@ -273,6 +289,35 @@ func (p *Pipeline) CallLLM( continue } + if isNetworkError && retry < maxRetries { + backoff := time.Duration(retry+1) * time.Duration(backoffSecs) * time.Second + al.emitEvent( + EventKindLLMRetry, + ts.eventMeta("runTurn", "turn.llm.retry"), + LLMRetryPayload{ + Attempt: retry + 1, + MaxRetries: maxRetries, + Reason: "network", + Error: err.Error(), + Backoff: backoff, + }, + ) + logger.WarnCF("agent", "Network error, retrying after backoff", map[string]any{ + "error": err.Error(), + "retry": retry, + "backoff": backoff.String(), + }) + if sleepErr := sleepWithContext(turnCtx, backoff); sleepErr != nil { + if ts.hardAbortRequested() { + _ = ts.requestHardAbort() + return ControlBreak, nil + } + err = sleepErr + break + } + continue + } + if isContextError && retry < maxRetries && !ts.opts.NoHistory { al.emitEvent( EventKindLLMRetry, diff --git a/pkg/config/config.go b/pkg/config/config.go index 5bc96fb12..804f4c67b 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -275,6 +275,8 @@ type AgentDefaults struct { SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker ContextManager string `json:"context_manager,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"` ContextManagerConfig json.RawMessage `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"` + MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` + LLMRetryBackoffSecs int `json:"llm_retry_backoff_secs,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_LLM_RETRY_BACKOFF_SECS"` } const DefaultMaxMediaSize = 20 * 1024 * 1024 // 20 MB From bcc3d447a188114a19c7f900be013e578b95d3c9 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 20:46:16 +0600 Subject: [PATCH 02/53] feat(agent): add pretty_print and disable_escape_html options for tool feedback - Add PrettyPrint and DisableEscapeHTML config options to ToolFeedbackConfig - Add FormatArgsJSON helper function with configurable pretty printing and HTML escaping - Add toolFeedbackArgsPreviewWithOptions to pass formatting options - Update pipeline_execute.go to use new formatting options for tool feedback This fixes the issue where '&&' would be displayed as '\u0026' in tool feedback messages and provides optional pretty-printing for better readability. --- pkg/agent/agent_utils.go | 9 +++++++++ pkg/agent/pipeline_execute.go | 4 ++-- pkg/config/config.go | 8 +++++--- pkg/config/defaults.go | 8 +++++--- pkg/utils/tool_feedback.go | 17 +++++++++++++++++ 5 files changed, 38 insertions(+), 8 deletions(-) diff --git a/pkg/agent/agent_utils.go b/pkg/agent/agent_utils.go index 4ba75cde4..90d9f43b9 100644 --- a/pkg/agent/agent_utils.go +++ b/pkg/agent/agent_utils.go @@ -184,6 +184,15 @@ func toolFeedbackArgsPreview(args map[string]any, maxLen int) string { return utils.Truncate(string(argsJSON), maxLen) } +func toolFeedbackArgsPreviewWithOptions(args map[string]any, maxLen int, prettyPrint, disableEscapeHTML bool) string { + if args == nil { + args = map[string]any{} + } + + argsJSON := utils.FormatArgsJSON(args, prettyPrint, disableEscapeHTML) + return utils.Truncate(argsJSON, maxLen) +} + func shouldPublishToolFeedback(cfg *config.Config, ts *turnState) bool { if ts == nil || ts.channel == "" || ts.opts.SuppressToolFeedback { return false diff --git a/pkg/agent/pipeline_execute.go b/pkg/agent/pipeline_execute.go index 0cf3eaa9a..ec3514f10 100644 --- a/pkg/agent/pipeline_execute.go +++ b/pkg/agent/pipeline_execute.go @@ -91,7 +91,7 @@ toolLoop: feedbackMsg := utils.FormatToolFeedbackMessage( toolName, toolFeedbackExplanation, - toolFeedbackArgsPreview(toolArgs, toolFeedbackMaxLen), + toolFeedbackArgsPreviewWithOptions(toolArgs, toolFeedbackMaxLen, al.cfg.Agents.Defaults.ToolFeedback.PrettyPrint, al.cfg.Agents.Defaults.ToolFeedback.DisableEscapeHTML), ) fbCtx, fbCancel := context.WithTimeout(turnCtx, 3*time.Second) _ = al.bus.PublishOutbound(fbCtx, outboundMessageForTurnWithKind(ts, feedbackMsg, messageKindToolFeedback)) @@ -373,7 +373,7 @@ toolLoop: feedbackMsg := utils.FormatToolFeedbackMessage( toolName, toolFeedbackExplanation, - toolFeedbackArgsPreview(toolArgs, toolFeedbackMaxLen), + toolFeedbackArgsPreviewWithOptions(toolArgs, toolFeedbackMaxLen, al.cfg.Agents.Defaults.ToolFeedback.PrettyPrint, al.cfg.Agents.Defaults.ToolFeedback.DisableEscapeHTML), ) fbCtx, fbCancel := context.WithTimeout(turnCtx, 3*time.Second) _ = al.bus.PublishOutbound(fbCtx, outboundMessageForTurnWithKind(ts, feedbackMsg, messageKindToolFeedback)) diff --git a/pkg/config/config.go b/pkg/config/config.go index 6bb8d3ce6..0cbc6fead 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -247,9 +247,11 @@ type SubTurnConfig struct { } type ToolFeedbackConfig struct { - Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` - MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` - SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` + Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` + MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` + SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` + PrettyPrint bool `json:"pretty_print" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_PRETTY_PRINT"` + DisableEscapeHTML bool `json:"disable_escape_html" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_DISABLE_ESCAPE_HTML"` } type AgentDefaults struct { diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index f3aaca7ab..7725b040e 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -35,9 +35,11 @@ func DefaultConfig() *Config { SummarizeTokenPercent: 75, SteeringMode: "one-at-a-time", ToolFeedback: ToolFeedbackConfig{ - Enabled: false, - MaxArgsLength: 300, - SeparateMessages: false, + Enabled: false, + MaxArgsLength: 300, + SeparateMessages: false, + PrettyPrint: true, + DisableEscapeHTML: true, }, SplitOnMarker: false, }, diff --git a/pkg/utils/tool_feedback.go b/pkg/utils/tool_feedback.go index de7cb467e..4e80e57f3 100644 --- a/pkg/utils/tool_feedback.go +++ b/pkg/utils/tool_feedback.go @@ -1,12 +1,29 @@ package utils import ( + "bytes" + "encoding/json" "fmt" "strings" ) const ToolFeedbackContinuationHint = "Continuing the current task." +func FormatArgsJSON(args map[string]any, prettyPrint, disableEscapeHTML bool) string { + var buf bytes.Buffer + enc := json.NewEncoder(&buf) + if prettyPrint { + enc.SetIndent("", " ") + } + if disableEscapeHTML { + enc.SetEscapeHTML(false) + } + if err := enc.Encode(args); err != nil { + return "{}" + } + return strings.TrimSpace(buf.String()) +} + // FormatToolFeedbackMessage renders a tool feedback message for chat channels. // It keeps the tool name on the first line for animation and can include both // a human explanation and the serialized tool arguments in the body. From fc89fea319bb8d8cde70ea488965836edf0caac8 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 21:14:06 +0600 Subject: [PATCH 03/53] test(utils): add unit tests for FormatArgsJSON Add tests for FormatArgsJSON covering: - Default compact JSON output - Pretty print formatting - HTML escape disabling (preserves &&, <, >) - Combined pretty print and escape disable - Default HTML escaping behavior - Nil args handling --- pkg/utils/tool_feedback_test.go | 100 +++++++++++++++++++++++++++++++- 1 file changed, 99 insertions(+), 1 deletion(-) diff --git a/pkg/utils/tool_feedback_test.go b/pkg/utils/tool_feedback_test.go index c30f53827..5fabd3d83 100644 --- a/pkg/utils/tool_feedback_test.go +++ b/pkg/utils/tool_feedback_test.go @@ -1,6 +1,9 @@ package utils -import "testing" +import ( + "encoding/json" + "testing" +) func TestFormatToolFeedbackMessage(t *testing.T) { got := FormatToolFeedbackMessage( @@ -56,3 +59,98 @@ func TestFitToolFeedbackMessage_TruncatesSingleLineMessage(t *testing.T) { t.Fatalf("FitToolFeedbackMessage() = %q, want %q", got, want) } } + +func TestFormatArgsJSON_Defaults(t *testing.T) { + args := map[string]any{"path": "README.md", "line": 42} + got := FormatArgsJSON(args, false, false) + var gotVal, wantVal any + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + want := `{"path":"README.md","line":42}` + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_PrettyPrint(t *testing.T) { + args := map[string]any{"path": "README.md", "line": 42} + got := FormatArgsJSON(args, true, false) + var gotVal any + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + want := `{"path":"README.md","line":42}` + var wantVal any + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() prettyPrint = %q, want structure %q", got, want) + } +} + +func TestFormatArgsJSON_DisableEscapeHTML(t *testing.T) { + args := map[string]any{"msg": "a < b && c > d"} + got := FormatArgsJSON(args, false, true) + var gotVal, wantVal any + want := `{"msg":"a < b && c > d"}` + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() disableEscapeHTML = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_PrettyPrintAndDisableEscapeHTML(t *testing.T) { + args := map[string]any{"msg": "a < b && c > d"} + got := FormatArgsJSON(args, true, true) + var gotVal, wantVal any + want := `{"msg":"a < b && c > d"}` + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() combined = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_EscapeHTMLByDefault(t *testing.T) { + args := map[string]any{"msg": "a < b && c > d"} + got := FormatArgsJSON(args, false, false) + var gotVal, wantVal any + want := `{"msg":"a \u003c b \u0026\u0026 c \u003e d"}` + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() default escape = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_NilArgs(t *testing.T) { + got := FormatArgsJSON(nil, false, false) + want := `null` + if got != want { + t.Fatalf("FormatArgsJSON() nil = %q, want %q", got, want) + } +} + +func jsonValEq(a, b any) bool { + aJSON, _ := json.Marshal(a) + bJSON, _ := json.Marshal(b) + return string(aJSON) == string(bJSON) +} From 3c4523e7aaeb969d2530f4cb812219c32b65c946 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 21:19:13 +0600 Subject: [PATCH 04/53] test(agent): add unit tests for network error retry backoff strategy - Test all network error types trigger retry (connection_reset, broken_pipe, read_tcp, eof, connection_refused) - Test custom MaxLLMRetries and LLMRetryBackoffSecs config is respected - Test retry count limit (1 initial + maxRetries retries) - Add countingErrorProvider mock for deterministic call count verification --- pkg/agent/turn_coord_test.go | 167 +++++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) diff --git a/pkg/agent/turn_coord_test.go b/pkg/agent/turn_coord_test.go index 7a362a662..9e1eaaf40 100644 --- a/pkg/agent/turn_coord_test.go +++ b/pkg/agent/turn_coord_test.go @@ -106,6 +106,16 @@ func (p *errorProvider) Chat( return nil, errors.New("context_length_exceeded") case "vision": return nil, errors.New("vision_unsupported") + case "connection_reset": + return nil, errors.New("connection reset by peer") + case "broken_pipe": + return nil, errors.New("broken pipe") + case "read_tcp": + return nil, errors.New("read tcp 127.0.0.1:8080: connection reset") + case "eof": + return nil, errors.New("EOF") + case "connection_refused": + return nil, errors.New("connection refused") default: return nil, errors.New("unknown error") } @@ -302,6 +312,163 @@ func TestPipeline_CallLLM_ContextLengthError(t *testing.T) { t.Logf("CallLLM result after context error: err=%v", err) } +func TestPipeline_CallLLM_NetworkErrorRetry(t *testing.T) { + testCases := []struct { + name string + errType string + }{ + {"connection_reset", "connection_reset"}, + {"broken_pipe", "broken_pipe"}, + {"read_tcp", "read_tcp"}, + {"eof", "eof"}, + {"connection_refused", "connection_refused"}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + errorPrv := &errorProvider{errType: tc.errType} + al, agent, cleanup := newTurnCoordTestLoop(t, errorPrv) + defer cleanup() + + pipeline := NewPipeline(al) + ts := newTurnState(agent, makeTestProcessOpts("test-session"), turnEventScope{ + turnID: "turn-1", + context: newTurnContext(nil, nil, nil), + }) + + exec, err := pipeline.SetupTurn(context.Background(), ts) + if err != nil { + t.Fatalf("SetupTurn failed: %v", err) + } + + _, err = pipeline.CallLLM(context.Background(), context.Background(), ts, exec, 1) + if err == nil { + t.Error("expected error after network error retries") + } + }) + } +} + +func TestPipeline_CallLLM_RetryConfigRespected(t *testing.T) { + tmpDir := t.TempDir() + + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: tmpDir, + ModelName: "test-model", + MaxTokens: 4096, + MaxToolIterations: 10, + MaxLLMRetries: 3, + LLMRetryBackoffSecs: 1, + }, + }, + } + + msgBus := bus.NewMessageBus() + provider := &errorProvider{errType: "connection_reset"} + al := NewAgentLoop(cfg, msgBus, provider) + defer al.Close() + agent := al.registry.GetDefaultAgent() + if agent == nil { + t.Fatal("expected default agent") + } + + pipeline := NewPipeline(al) + ts := newTurnState(agent, makeTestProcessOpts("test-session"), turnEventScope{ + turnID: "turn-1", + context: newTurnContext(nil, nil, nil), + }) + + exec, err := pipeline.SetupTurn(context.Background(), ts) + if err != nil { + t.Fatalf("SetupTurn failed: %v", err) + } + + start := time.Now() + _, err = pipeline.CallLLM(context.Background(), context.Background(), ts, exec, 1) + elapsed := time.Since(start) + + if err == nil { + t.Error("expected error after retries") + } + + expectedMinTime := 3 * time.Second + if elapsed < expectedMinTime { + t.Errorf("expected at least %v of backoff, got %v", expectedMinTime, elapsed) + } +} + +func TestPipeline_CallLLM_RetryCountLimit(t *testing.T) { + tmpDir := t.TempDir() + + counterPrv := &countingErrorProvider{errType: "connection_reset", targetCalls: 5} + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: tmpDir, + ModelName: "test-model", + MaxTokens: 4096, + MaxToolIterations: 10, + MaxLLMRetries: 2, + LLMRetryBackoffSecs: 0, + }, + }, + } + + msgBus := bus.NewMessageBus() + al := NewAgentLoop(cfg, msgBus, counterPrv) + defer al.Close() + agent := al.registry.GetDefaultAgent() + if agent == nil { + t.Fatal("expected default agent") + } + + pipeline := NewPipeline(al) + ts := newTurnState(agent, makeTestProcessOpts("test-session"), turnEventScope{ + turnID: "turn-1", + context: newTurnContext(nil, nil, nil), + }) + + exec, err := pipeline.SetupTurn(context.Background(), ts) + if err != nil { + t.Fatalf("SetupTurn failed: %v", err) + } + + _, err = pipeline.CallLLM(context.Background(), context.Background(), ts, exec, 1) + if err == nil { + t.Error("expected error after retries") + } + + if counterPrv.callCount != 3 { + t.Errorf("expected exactly 3 calls (1 initial + 2 retries), got %d", counterPrv.callCount) + } +} + +type countingErrorProvider struct { + errType string + targetCalls int + callCount int + mu sync.Mutex +} + +func (p *countingErrorProvider) Chat( + ctx context.Context, + messages []providers.Message, + tools []providers.ToolDefinition, + model string, + opts map[string]any, +) (*providers.LLMResponse, error) { + p.mu.Lock() + p.callCount++ + p.mu.Unlock() + return nil, errors.New("connection reset by peer") +} + +func (p *countingErrorProvider) GetDefaultModel() string { + return "counting-error-model" +} + // ============================================================================= // Pipeline Method Tests: ExecuteTools // ============================================================================= From d2f6a089818dd3207f8007f9af471dd59f5a8eca Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 22:07:16 +0600 Subject: [PATCH 05/53] fix(config): align gci formatting for MaxLLMRetries field --- pkg/config/config.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index 804f4c67b..10d9da7e0 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -275,7 +275,7 @@ type AgentDefaults struct { SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker ContextManager string `json:"context_manager,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"` ContextManagerConfig json.RawMessage `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"` - MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` + MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` LLMRetryBackoffSecs int `json:"llm_retry_backoff_secs,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_LLM_RETRY_BACKOFF_SECS"` } From 32c8b8ce6ae523f8ee29e50c99fd68f735240fd4 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 22:09:44 +0600 Subject: [PATCH 06/53] chore(config): add default values for max_llm_retries and llm_retry_backoff_secs --- config/config.example.json | 2 ++ pkg/config/defaults.go | 8 +++++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/config/config.example.json b/config/config.example.json index 858472488..cf96e19a8 100644 --- a/config/config.example.json +++ b/config/config.example.json @@ -11,6 +11,8 @@ "summarize_message_threshold": 20, "summarize_token_percent": 75, "split_on_marker": false, + "max_llm_retries": 2, + "llm_retry_backoff_secs": 2, "tool_feedback": { "enabled": false, "max_args_length": 300 diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index 3d12c6ba5..0d24bebe3 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -38,10 +38,12 @@ func DefaultConfig() *Config { Enabled: false, MaxArgsLength: 300, }, - SplitOnMarker: false, - }, + SplitOnMarker: false, + MaxLLMRetries: 2, + LLMRetryBackoffSecs: 2, }, - Session: SessionConfig{ + }, + Session: SessionConfig{ Dimensions: []string{"chat"}, }, Channels: defaultChannels(), From 1b2f8aac7998a72c51d2081941fdebf7349a7fc5 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 22:12:41 +0600 Subject: [PATCH 07/53] fix(config): align indentation for new LLM retry default fields --- pkg/config/defaults.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index 0d24bebe3..959877e60 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -38,12 +38,12 @@ func DefaultConfig() *Config { Enabled: false, MaxArgsLength: 300, }, - SplitOnMarker: false, - MaxLLMRetries: 2, - LLMRetryBackoffSecs: 2, + SplitOnMarker: false, + MaxLLMRetries: 2, + LLMRetryBackoffSecs: 2, + }, }, - }, - Session: SessionConfig{ + Session: SessionConfig{ Dimensions: []string{"chat"}, }, Channels: defaultChannels(), From bdaff5cb693f2c5efbc0105c19d9c8459e7dab2c Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 22:27:01 +0600 Subject: [PATCH 08/53] Add pretty_print and disable_escape_html to tool_feedback defaults --- config/config.example.json | 4 +- go.mod | 2 +- pkg/config/config.go | 2 +- pkg/config/defaults.go | 2 +- tool_feedback.go | 86 +++++++++++++++++++++++++++++++ tool_feedback_test.go | 101 +++++++++++++++++++++++++++++++++++++ 6 files changed, 193 insertions(+), 4 deletions(-) create mode 100644 tool_feedback.go create mode 100644 tool_feedback_test.go diff --git a/config/config.example.json b/config/config.example.json index 30460c231..665a6fd11 100644 --- a/config/config.example.json +++ b/config/config.example.json @@ -14,7 +14,9 @@ "tool_feedback": { "enabled": false, "max_args_length": 300, - "separate_messages": false + "separate_messages": false, + "pretty_print": true, + "disable_escape_html": true } } }, diff --git a/go.mod b/go.mod index 4afbe9d85..e4326d8ab 100644 --- a/go.mod +++ b/go.mod @@ -122,7 +122,7 @@ require ( github.com/github/copilot-sdk/go v0.2.0 github.com/go-resty/resty/v2 v2.17.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect - github.com/google/jsonschema-go v0.4.2 // indirect + github.com/google/jsonschema-go v0.4.2 github.com/grbit/go-json v0.11.0 // indirect github.com/klauspost/compress v1.18.4 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect diff --git a/pkg/config/config.go b/pkg/config/config.go index 0cbc6fead..d4908aca3 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -251,7 +251,7 @@ type ToolFeedbackConfig struct { MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` PrettyPrint bool `json:"pretty_print" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_PRETTY_PRINT"` - DisableEscapeHTML bool `json:"disable_escape_html" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_DISABLE_ESCAPE_HTML"` + DisableEscapeHTML bool `json:"disable_escape_html" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_DISABLE_ESCAPE_HTML"` } type AgentDefaults struct { diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index 7725b040e..32e3cbbe1 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -39,7 +39,7 @@ func DefaultConfig() *Config { MaxArgsLength: 300, SeparateMessages: false, PrettyPrint: true, - DisableEscapeHTML: true, + DisableEscapeHTML: true, }, SplitOnMarker: false, }, diff --git a/tool_feedback.go b/tool_feedback.go new file mode 100644 index 000000000..b8cf3c384 --- /dev/null +++ b/tool_feedback.go @@ -0,0 +1,86 @@ +package utils + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" +) + +const ToolFeedbackContinuationHint = "Continuing the current task." + +func FormatArgsJSON(args map[string]any, prettyPrint, disableEscapeHTML bool) string { + var buf bytes.Buffer + enc := json.NewEncoder(&buf) + if prettyPrint { + enc.SetIndent("", " ") + } + if disableEscapeHTML { + enc.SetEscapeHTML(false) + } + if err := enc.Encode(args); err != nil { + return "{}" + } + return strings.TrimSpace(buf.String()) +} + +func FormatToolFeedbackMessage(toolName, explanation, argsPreview string) string { + toolName = strings.TrimSpace(toolName) + explanation = strings.TrimSpace(explanation) + argsPreview = strings.TrimSpace(argsPreview) + + bodyLines := make([]string, 0, 2) + if explanation != "" { + bodyLines = append(bodyLines, explanation) + } + if argsPreview != "" { + bodyLines = append(bodyLines, "```json\n"+argsPreview+"\n```") + } + body := strings.Join(bodyLines, "\n") + + if toolName == "" { + return body + } + if body == "" { + return fmt.Sprintf("\U0001f527 `%s`", toolName) + } + + return fmt.Sprintf("\U0001f527 `%s`\n%s", toolName, body) +} + +func FitToolFeedbackMessage(content string, maxLen int) string { + content = strings.TrimSpace(content) + if content == "" || maxLen <= 0 { + return "" + } + if len([]rune(content)) <= maxLen { + return content + } + + firstLine, rest, hasRest := strings.Cut(content, "\n") + firstLine = strings.TrimSpace(firstLine) + rest = strings.TrimSpace(rest) + + if !hasRest || rest == "" { + return Truncate(firstLine, maxLen) + } + + if len([]rune(firstLine)) >= maxLen { + return Truncate(firstLine, maxLen) + } + + remaining := maxLen - len([]rune(firstLine)) - 1 + if remaining <= 0 { + return Truncate(firstLine, maxLen) + } + + return firstLine + "\n" + Truncate(rest, remaining) +} + +func Truncate(s string, maxLen int) string { + runes := []rune(s) + if len(runes) <= maxLen { + return s + } + return string(runes[:maxLen]) +} diff --git a/tool_feedback_test.go b/tool_feedback_test.go new file mode 100644 index 000000000..ef76c1506 --- /dev/null +++ b/tool_feedback_test.go @@ -0,0 +1,101 @@ +package utils + +import ( + "encoding/json" + "testing" +) + +func TestFormatArgsJSON_Defaults(t *testing.T) { + args := map[string]any{"path": "README.md", "line": 42} + got := FormatArgsJSON(args, false, false) + var gotVal, wantVal any + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + want := `{"path":"README.md","line":42}` + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_PrettyPrint(t *testing.T) { + args := map[string]any{"path": "README.md", "line": 42} + got := FormatArgsJSON(args, true, false) + var gotVal any + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + want := `{"path":"README.md","line":42}` + var wantVal any + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() prettyPrint = %q, want structure %q", got, want) + } +} + +func TestFormatArgsJSON_DisableEscapeHTML(t *testing.T) { + args := map[string]any{"msg": "a < b && c > d"} + got := FormatArgsJSON(args, false, true) + var gotVal, wantVal any + want := `{"msg":"a < b && c > d"}` + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() disableEscapeHTML = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_PrettyPrintAndDisableEscapeHTML(t *testing.T) { + args := map[string]any{"msg": "a < b && c > d"} + got := FormatArgsJSON(args, true, true) + var gotVal, wantVal any + want := `{"msg":"a < b && c > d"}` + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() combined = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_EscapeHTMLByDefault(t *testing.T) { + args := map[string]any{"msg": "a < b && c > d"} + got := FormatArgsJSON(args, false, false) + var gotVal, wantVal any + want := `{"msg":"a \u003c b \u0026\u0026 c \u003e d"}` + if err := json.Unmarshal([]byte(got), &gotVal); err != nil { + t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) + } + if err := json.Unmarshal([]byte(want), &wantVal); err != nil { + t.Fatalf("invalid test want JSON: %v", err) + } + if !jsonValEq(gotVal, wantVal) { + t.Fatalf("FormatArgsJSON() default escape = %q, want %q", got, want) + } +} + +func TestFormatArgsJSON_NilArgs(t *testing.T) { + got := FormatArgsJSON(nil, false, false) + want := `null` + if got != want { + t.Fatalf("FormatArgsJSON() nil = %q, want %q", got, want) + } +} + +func jsonValEq(a, b any) bool { + aJSON, _ := json.Marshal(a) + bJSON, _ := json.Marshal(b) + return string(aJSON) == string(bJSON) +} From 612097b41139a6a78bb3d44aa5cf031d21d786be Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 23:01:45 +0600 Subject: [PATCH 09/53] fix(config): align gci formatting for LLM retry fields --- pkg/config/config.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index 10d9da7e0..b8d92b57f 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -275,8 +275,8 @@ type AgentDefaults struct { SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker ContextManager string `json:"context_manager,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"` ContextManagerConfig json.RawMessage `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"` - MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` - LLMRetryBackoffSecs int `json:"llm_retry_backoff_secs,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_LLM_RETRY_BACKOFF_SECS"` + MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` + LLMRetryBackoffSecs int `json:"llm_retry_backoff_secs,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_LLM_RETRY_BACKOFF_SECS"` } const DefaultMaxMediaSize = 20 * 1024 * 1024 // 20 MB From 9bc702ebaf5570fd10e16b87b2d683d1e2cd93b6 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 23:09:40 +0600 Subject: [PATCH 10/53] fix test: enable pretty_print in tool feedback test --- pkg/agent/agent_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pkg/agent/agent_test.go b/pkg/agent/agent_test.go index 01657d43a..6e5bc8191 100644 --- a/pkg/agent/agent_test.go +++ b/pkg/agent/agent_test.go @@ -4519,7 +4519,8 @@ func TestRun_PicoToolFeedbackSuppressesDuplicateInterimAssistantContent(t *testi MaxTokens: 4096, MaxToolIterations: 10, ToolFeedback: config.ToolFeedbackConfig{ - Enabled: true, + Enabled: true, + PrettyPrint: true, }, }, }, From 4ddd650be44d6e0ec4724437d0a16c64e6fa2d54 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sun, 26 Apr 2026 07:06:36 +0600 Subject: [PATCH 11/53] align ToolFeedbackConfig field spacing --- pkg/config/config.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index d4908aca3..b31c2b63d 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -248,10 +248,10 @@ type SubTurnConfig struct { type ToolFeedbackConfig struct { Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` - MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` - SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` - PrettyPrint bool `json:"pretty_print" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_PRETTY_PRINT"` - DisableEscapeHTML bool `json:"disable_escape_html" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_DISABLE_ESCAPE_HTML"` + MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` + SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` + PrettyPrint bool `json:"pretty_print" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_PRETTY_PRINT"` + DisableEscapeHTML bool `json:"disable_escape_html" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_DISABLE_ESCAPE_HTML"` } type AgentDefaults struct { From f0dc709b17de4e358e36327992346e5ee963427a Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sun, 26 Apr 2026 07:07:19 +0600 Subject: [PATCH 12/53] fix(config): fix golines max-len for MaxLLMRetries field --- pkg/config/config.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index b8d92b57f..80a7a79a7 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -275,7 +275,7 @@ type AgentDefaults struct { SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker ContextManager string `json:"context_manager,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"` ContextManagerConfig json.RawMessage `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"` - MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` + MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` LLMRetryBackoffSecs int `json:"llm_retry_backoff_secs,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_LLM_RETRY_BACKOFF_SECS"` } From eedebabbeabfb616b919297354434baf2b8c2f6c Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 15:36:03 +0800 Subject: [PATCH 13/53] feat(events): add runtime event bus Introduce pkg/events with filtered channels, subscription policies, backpressure, and stats. Wire AgentLoop to dual-publish legacy agent events into runtime events while preserving old event APIs. Validation: go test ./pkg/events/... ./pkg/agent; go test -race ./pkg/events/...; make lint --- pkg/agent/agent.go | 15 +- pkg/agent/agent_event.go | 24 +- pkg/agent/agent_init.go | 30 ++- pkg/agent/agent_options.go | 20 ++ pkg/agent/event_kind_runtime.go | 48 ++++ pkg/agent/eventbus_test.go | 125 +++++++++++ pkg/agent/events_runtime.go | 104 +++++++++ pkg/events/bus.go | 233 +++++++++++++++++++ pkg/events/channel.go | 75 +++++++ pkg/events/doc.go | 3 + pkg/events/events_test.go | 155 +++++++++++++ pkg/events/filter.go | 131 +++++++++++ pkg/events/filter_test.go | 96 ++++++++ pkg/events/kind.go | 68 ++++++ pkg/events/stats.go | 26 +++ pkg/events/subscription.go | 384 ++++++++++++++++++++++++++++++++ pkg/events/subscription_test.go | 156 +++++++++++++ pkg/events/types.go | 77 +++++++ 18 files changed, 1757 insertions(+), 13 deletions(-) create mode 100644 pkg/agent/agent_options.go create mode 100644 pkg/agent/event_kind_runtime.go create mode 100644 pkg/agent/events_runtime.go create mode 100644 pkg/events/bus.go create mode 100644 pkg/events/channel.go create mode 100644 pkg/events/doc.go create mode 100644 pkg/events/events_test.go create mode 100644 pkg/events/filter.go create mode 100644 pkg/events/filter_test.go create mode 100644 pkg/events/kind.go create mode 100644 pkg/events/stats.go create mode 100644 pkg/events/subscription.go create mode 100644 pkg/events/subscription_test.go create mode 100644 pkg/events/types.go diff --git a/pkg/agent/agent.go b/pkg/agent/agent.go index 3e9bd845e..2bec6897f 100644 --- a/pkg/agent/agent.go +++ b/pkg/agent/agent.go @@ -21,6 +21,7 @@ import ( "github.com/sipeed/picoclaw/pkg/commands" "github.com/sipeed/picoclaw/pkg/config" "github.com/sipeed/picoclaw/pkg/constants" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/media" "github.com/sipeed/picoclaw/pkg/providers" @@ -38,8 +39,10 @@ type AgentLoop struct { state *state.Manager // Event system (from Incoming) - eventBus *EventBus - hooks *HookManager + eventBus *EventBus + runtimeEvents runtimeevents.Bus + ownsRuntimeEvents bool + hooks *HookManager // Runtime state running atomic.Bool @@ -286,6 +289,14 @@ func (al *AgentLoop) Close() { if al.eventBus != nil { al.eventBus.Close() } + if al.runtimeEvents != nil && al.ownsRuntimeEvents { + if err := al.runtimeEvents.Close(); err != nil { + logger.ErrorCF("agent", "Failed to close runtime event bus", + map[string]any{ + "error": err.Error(), + }) + } + } } // MountHook registers an in-process hook on the agent loop. diff --git a/pkg/agent/agent_event.go b/pkg/agent/agent_event.go index 9b8625df1..d634d8707 100644 --- a/pkg/agent/agent_event.go +++ b/pkg/agent/agent_event.go @@ -5,6 +5,7 @@ package agent import ( "fmt" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" ) @@ -39,13 +40,16 @@ func (al *AgentLoop) emitEvent(kind EventKind, meta EventMeta, payload any) { Payload: payload, } - if al == nil || al.eventBus == nil { + if al == nil { return } al.logEvent(evt) - al.eventBus.Emit(evt) + if al.eventBus != nil { + al.eventBus.Emit(evt) + } + al.publishRuntimeEvent(evt) } func (al *AgentLoop) logEvent(evt Event) { @@ -186,3 +190,19 @@ func (al *AgentLoop) EventDrops(kind EventKind) int64 { } return al.eventBus.Dropped(kind) } + +// RuntimeEvents returns the root runtime event channel. +func (al *AgentLoop) RuntimeEvents() runtimeevents.EventChannel { + if al == nil || al.runtimeEvents == nil { + return nil + } + return al.runtimeEvents.Channel() +} + +// RuntimeEventStats returns runtime event bus counters. +func (al *AgentLoop) RuntimeEventStats() runtimeevents.Stats { + if al == nil || al.runtimeEvents == nil { + return runtimeevents.Stats{Closed: true} + } + return al.runtimeEvents.Stats() +} diff --git a/pkg/agent/agent_init.go b/pkg/agent/agent_init.go index 611d634e8..da2e79aa8 100644 --- a/pkg/agent/agent_init.go +++ b/pkg/agent/agent_init.go @@ -13,6 +13,7 @@ import ( "github.com/sipeed/picoclaw/pkg/channels" "github.com/sipeed/picoclaw/pkg/commands" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/skills" @@ -24,6 +25,7 @@ func NewAgentLoop( cfg *config.Config, msgBus *bus.MessageBus, provider providers.LLMProvider, + opts ...AgentLoopOption, ) *AgentLoop { registry := NewAgentRegistry(cfg, provider) @@ -56,15 +58,25 @@ func NewAgentLoop( } al := &AgentLoop{ - bus: msgBus, - cfg: cfg, - registry: registry, - state: stateManager, - eventBus: eventBus, - fallback: fallbackChain, - cmdRegistry: commands.NewRegistry(commands.BuiltinDefinitions()), - steering: newSteeringQueue(parseSteeringMode(cfg.Agents.Defaults.SteeringMode)), - workerSem: make(chan struct{}, workerPoolSize), + bus: msgBus, + cfg: cfg, + registry: registry, + state: stateManager, + eventBus: eventBus, + fallback: fallbackChain, + cmdRegistry: commands.NewRegistry(commands.BuiltinDefinitions()), + steering: newSteeringQueue(parseSteeringMode(cfg.Agents.Defaults.SteeringMode)), + workerSem: make(chan struct{}, workerPoolSize), + ownsRuntimeEvents: true, + } + for _, opt := range opts { + if opt != nil { + opt(al) + } + } + if al.runtimeEvents == nil { + al.runtimeEvents = runtimeevents.NewBus() + al.ownsRuntimeEvents = true } al.providerFactory = providers.CreateProviderFromConfig al.hooks = NewHookManager(eventBus) diff --git a/pkg/agent/agent_options.go b/pkg/agent/agent_options.go new file mode 100644 index 000000000..224062a3f --- /dev/null +++ b/pkg/agent/agent_options.go @@ -0,0 +1,20 @@ +package agent + +import runtimeevents "github.com/sipeed/picoclaw/pkg/events" + +// AgentLoopOption configures an AgentLoop at construction time. +type AgentLoopOption func(*AgentLoop) + +// WithRuntimeEvents injects the runtime event bus used for new observation APIs. +// +// The injected bus is treated as externally owned and will not be closed by +// AgentLoop.Close. Passing nil leaves the default owned runtime bus enabled. +func WithRuntimeEvents(bus runtimeevents.Bus) AgentLoopOption { + return func(al *AgentLoop) { + if bus == nil { + return + } + al.runtimeEvents = bus + al.ownsRuntimeEvents = false + } +} diff --git a/pkg/agent/event_kind_runtime.go b/pkg/agent/event_kind_runtime.go new file mode 100644 index 000000000..031f3b35e --- /dev/null +++ b/pkg/agent/event_kind_runtime.go @@ -0,0 +1,48 @@ +package agent + +import runtimeevents "github.com/sipeed/picoclaw/pkg/events" + +func runtimeKindForAgentEvent(kind EventKind) runtimeevents.Kind { + switch kind { + case EventKindTurnStart: + return runtimeevents.KindAgentTurnStart + case EventKindTurnEnd: + return runtimeevents.KindAgentTurnEnd + case EventKindLLMRequest: + return runtimeevents.KindAgentLLMRequest + case EventKindLLMDelta: + return runtimeevents.KindAgentLLMDelta + case EventKindLLMResponse: + return runtimeevents.KindAgentLLMResponse + case EventKindLLMRetry: + return runtimeevents.KindAgentLLMRetry + case EventKindContextCompress: + return runtimeevents.KindAgentContextCompress + case EventKindSessionSummarize: + return runtimeevents.KindAgentSessionSummarize + case EventKindToolExecStart: + return runtimeevents.KindAgentToolExecStart + case EventKindToolExecEnd: + return runtimeevents.KindAgentToolExecEnd + case EventKindToolExecSkipped: + return runtimeevents.KindAgentToolExecSkipped + case EventKindSteeringInjected: + return runtimeevents.KindAgentSteeringInjected + case EventKindFollowUpQueued: + return runtimeevents.KindAgentFollowUpQueued + case EventKindInterruptReceived: + return runtimeevents.KindAgentInterruptReceived + case EventKindSubTurnSpawn: + return runtimeevents.KindAgentSubTurnSpawn + case EventKindSubTurnEnd: + return runtimeevents.KindAgentSubTurnEnd + case EventKindSubTurnResultDelivered: + return runtimeevents.KindAgentSubTurnResultDelivered + case EventKindSubTurnOrphan: + return runtimeevents.KindAgentSubTurnOrphan + case EventKindError: + return runtimeevents.KindAgentError + default: + return runtimeevents.Kind("agent." + kind.String()) + } +} diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 31b996260..4a5de46c9 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -9,6 +9,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" "github.com/sipeed/picoclaw/pkg/session" @@ -67,6 +68,100 @@ func TestEventBus_DropsWhenSubscriberIsFull(t *testing.T) { } } +func TestAgentLoop_DualPublishesRuntimeEvents(t *testing.T) { + runtimeBus := runtimeevents.NewBus() + al := &AgentLoop{ + eventBus: NewEventBus(), + runtimeEvents: runtimeBus, + } + defer al.eventBus.Close() + defer func() { + if err := runtimeBus.Close(); err != nil { + t.Errorf("runtime bus close failed: %v", err) + } + }() + + legacySub := al.SubscribeEvents(1) + defer al.UnsubscribeEvents(legacySub.ID) + + runtimeSub, runtimeCh, err := al.RuntimeEvents().OfKind(runtimeevents.KindAgentToolExecStart).SubscribeChan( + context.Background(), + runtimeevents.SubscribeOptions{Name: "runtime", Buffer: 1}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + defer func() { + if err := runtimeSub.Close(); err != nil { + t.Errorf("runtime subscription close failed: %v", err) + } + }() + + al.emitEvent( + EventKindToolExecStart, + EventMeta{ + AgentID: "main", + TurnID: "turn-1", + ParentTurnID: "parent-turn", + SessionKey: "session-1", + Iteration: 2, + TracePath: "trace/root", + Source: "pipeline_execute", + turnContext: &TurnContext{ + Inbound: &bus.InboundContext{ + Channel: "cli", + Account: "default", + ChatID: "direct", + ChatType: "direct", + SenderID: "tester", + MessageID: "msg-1", + TopicID: "topic-1", + }, + }, + }, + ToolExecStartPayload{Tool: "mock_custom", Arguments: map[string]any{"task": "ping"}}, + ) + + legacyEvt := receiveLegacyEvent(t, legacySub.C) + if legacyEvt.Kind != EventKindToolExecStart { + t.Fatalf("legacy kind = %v, want %v", legacyEvt.Kind, EventKindToolExecStart) + } + + runtimeEvt := receiveRuntimeEvent(t, runtimeCh) + if runtimeEvt.Kind != runtimeevents.KindAgentToolExecStart { + t.Fatalf("runtime kind = %q, want %q", runtimeEvt.Kind, runtimeevents.KindAgentToolExecStart) + } + if runtimeEvt.Source != (runtimeevents.Source{Component: "agent", Name: "main"}) { + t.Fatalf("runtime source = %+v", runtimeEvt.Source) + } + if runtimeEvt.Scope.AgentID != "main" || + runtimeEvt.Scope.SessionKey != "session-1" || + runtimeEvt.Scope.TurnID != "turn-1" || + runtimeEvt.Scope.Channel != "cli" || + runtimeEvt.Scope.Account != "default" || + runtimeEvt.Scope.ChatID != "direct" || + runtimeEvt.Scope.TopicID != "topic-1" || + runtimeEvt.Scope.ChatType != "direct" || + runtimeEvt.Scope.SenderID != "tester" || + runtimeEvt.Scope.MessageID != "msg-1" { + t.Fatalf("runtime scope = %+v", runtimeEvt.Scope) + } + if runtimeEvt.Correlation.TraceID != "trace/root" || + runtimeEvt.Correlation.ParentTurnID != "parent-turn" { + t.Fatalf("runtime correlation = %+v", runtimeEvt.Correlation) + } + if runtimeEvt.Attrs["agent_source"] != "pipeline_execute" || runtimeEvt.Attrs["iteration"] != 2 { + t.Fatalf("runtime attrs = %+v", runtimeEvt.Attrs) + } + payload, ok := runtimeEvt.Payload.(ToolExecStartPayload) + if !ok { + t.Fatalf("runtime payload = %T, want ToolExecStartPayload", runtimeEvt.Payload) + } + if payload.Tool != "mock_custom" { + t.Fatalf("runtime payload tool = %q, want mock_custom", payload.Tool) + } +} + type scriptedToolProvider struct { calls int } @@ -636,6 +731,36 @@ func collectEventStream(ch <-chan Event) []Event { } } +func receiveLegacyEvent(t *testing.T, ch <-chan Event) Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("legacy event stream closed before expected event arrived") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for legacy event") + return Event{} + } +} + +func receiveRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("runtime event stream closed before expected event arrived") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for runtime event") + return runtimeevents.Event{} + } +} + func waitForEvent(t *testing.T, ch <-chan Event, timeout time.Duration, match func(Event) bool) Event { t.Helper() diff --git a/pkg/agent/events_runtime.go b/pkg/agent/events_runtime.go new file mode 100644 index 000000000..822c7e23a --- /dev/null +++ b/pkg/agent/events_runtime.go @@ -0,0 +1,104 @@ +package agent + +import ( + "context" + "time" + + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +const runtimeEventPublishTimeout = 100 * time.Millisecond + +func (al *AgentLoop) publishRuntimeEvent(evt Event) { + if al == nil || al.runtimeEvents == nil { + return + } + + ctx, cancel := context.WithTimeout(context.Background(), runtimeEventPublishTimeout) + defer cancel() + + al.runtimeEvents.Publish(ctx, runtimeevents.Event{ + Kind: runtimeKindForAgentEvent(evt.Kind), + Source: runtimeevents.Source{Component: "agent", Name: evt.Meta.AgentID}, + Scope: runtimeScopeFromAgentEvent(evt), + Correlation: runtimeCorrelationFromAgentEvent(evt), + Severity: runtimeSeverityForAgentEvent(evt), + Payload: evt.Payload, + Attrs: runtimeAttrsFromAgentEvent(evt), + }) +} + +func runtimeScopeFromAgentEvent(evt Event) runtimeevents.Scope { + scope := runtimeevents.Scope{ + AgentID: evt.Meta.AgentID, + SessionKey: evt.Meta.SessionKey, + TurnID: evt.Meta.TurnID, + } + + if evt.Context == nil || evt.Context.Inbound == nil { + return scope + } + + inbound := evt.Context.Inbound + scope.Channel = inbound.Channel + scope.Account = inbound.Account + scope.ChatID = inbound.ChatID + scope.TopicID = inbound.TopicID + scope.SpaceID = inbound.SpaceID + scope.SpaceType = inbound.SpaceType + scope.ChatType = inbound.ChatType + scope.SenderID = inbound.SenderID + scope.MessageID = inbound.MessageID + return scope +} + +func runtimeCorrelationFromAgentEvent(evt Event) runtimeevents.Correlation { + return runtimeevents.Correlation{ + TraceID: evt.Meta.TracePath, + ParentTurnID: evt.Meta.ParentTurnID, + } +} + +func runtimeSeverityForAgentEvent(evt Event) runtimeevents.Severity { + switch evt.Kind { + case EventKindError, EventKindSubTurnOrphan: + return runtimeevents.SeverityError + case EventKindLLMRetry, EventKindContextCompress, EventKindToolExecSkipped: + return runtimeevents.SeverityWarn + case EventKindTurnEnd: + payload, ok := evt.Payload.(TurnEndPayload) + if !ok { + return runtimeevents.SeverityInfo + } + switch payload.Status { + case TurnEndStatusError: + return runtimeevents.SeverityError + case TurnEndStatusAborted: + return runtimeevents.SeverityWarn + default: + return runtimeevents.SeverityInfo + } + case EventKindToolExecEnd: + payload, ok := evt.Payload.(ToolExecEndPayload) + if ok && payload.IsError { + return runtimeevents.SeverityWarn + } + return runtimeevents.SeverityInfo + default: + return runtimeevents.SeverityInfo + } +} + +func runtimeAttrsFromAgentEvent(evt Event) map[string]any { + attrs := make(map[string]any, 2) + if evt.Meta.Source != "" { + attrs["agent_source"] = evt.Meta.Source + } + if evt.Meta.Iteration != 0 { + attrs["iteration"] = evt.Meta.Iteration + } + if len(attrs) == 0 { + return nil + } + return attrs +} diff --git a/pkg/events/bus.go b/pkg/events/bus.go new file mode 100644 index 000000000..80ed9eb80 --- /dev/null +++ b/pkg/events/bus.go @@ -0,0 +1,233 @@ +package events + +import ( + "context" + "sort" + "strconv" + "sync" + "sync/atomic" + "time" +) + +var globalEventSeq atomic.Uint64 + +// Bus publishes runtime events and creates filtered channels. +type Bus interface { + Publish(ctx context.Context, evt Event) PublishResult + Channel() EventChannel + Close() error + Stats() Stats +} + +// PublishResult reports per-publish delivery outcomes. +type PublishResult struct { + Matched int + Delivered int + Dropped int + Blocked int + Closed bool +} + +// EventBus is an in-process runtime event broadcaster. +type EventBus struct { + mu sync.RWMutex + subs map[uint64]*eventSubscription + closed bool + + nextSubID atomic.Uint64 + published atomic.Uint64 + matched atomic.Uint64 + delivered atomic.Uint64 + dropped atomic.Uint64 + blocked atomic.Uint64 +} + +var _ Bus = (*EventBus)(nil) + +// NewBus creates an in-process runtime event bus. +func NewBus() *EventBus { + return &EventBus{ + subs: make(map[uint64]*eventSubscription), + } +} + +// Publish broadcasts evt to subscriptions whose filters match it. +func (b *EventBus) Publish(ctx context.Context, evt Event) PublishResult { + if b == nil { + return PublishResult{Closed: true} + } + if ctx == nil { + ctx = context.Background() + } + if evt.Time.IsZero() { + evt.Time = time.Now() + } + if evt.ID == "" { + evt.ID = nextEventID() + } + + subs, closed := b.snapshotSubscribers() + if closed { + return PublishResult{Closed: true} + } + + b.published.Add(1) + result := PublishResult{} + + for _, sub := range subs { + if !matchesFilters(sub.filters, evt) { + continue + } + + result.Matched++ + b.matched.Add(1) + + delivery := sub.enqueue(ctx, evt) + if delivery.closed { + continue + } + result.Delivered += delivery.delivered + result.Dropped += delivery.dropped + result.Blocked += delivery.blocked + b.delivered.Add(uint64(delivery.delivered)) + b.dropped.Add(uint64(delivery.dropped)) + b.blocked.Add(uint64(delivery.blocked)) + } + + return result +} + +// Channel returns the root event channel for this bus. +func (b *EventBus) Channel() EventChannel { + return eventChannel{bus: b} +} + +// Close closes the bus and all active subscriptions. +func (b *EventBus) Close() error { + if b == nil { + return nil + } + + b.mu.Lock() + if b.closed { + b.mu.Unlock() + return nil + } + b.closed = true + subs := make([]*eventSubscription, 0, len(b.subs)) + for id, sub := range b.subs { + subs = append(subs, sub) + delete(b.subs, id) + } + b.mu.Unlock() + + for _, sub := range subs { + sub.closeInput() + } + return nil +} + +// Stats returns a snapshot of bus and subscription counters. +func (b *EventBus) Stats() Stats { + if b == nil { + return Stats{Closed: true} + } + + b.mu.RLock() + closed := b.closed + subs := make([]*eventSubscription, 0, len(b.subs)) + for _, sub := range b.subs { + subs = append(subs, sub) + } + b.mu.RUnlock() + + sortSubscriptions(subs) + + stats := Stats{ + Published: b.published.Load(), + Matched: b.matched.Load(), + Delivered: b.delivered.Load(), + Dropped: b.dropped.Load(), + Blocked: b.blocked.Load(), + Closed: closed, + Subscribers: len(subs), + SubscriberStats: make([]SubscriberStats, 0, len(subs)), + } + for _, sub := range subs { + stats.SubscriberStats = append(stats.SubscriberStats, sub.Stats()) + } + return stats +} + +func (b *EventBus) subscribe( + ctx context.Context, + filters []Filter, + opts SubscribeOptions, + handler Handler, + once bool, +) (Subscription, error) { + if b == nil { + return nil, ErrBusClosed + } + + id := b.nextSubID.Add(1) + sub := newSubscription(b, id, filters, opts, handler, once) + + b.mu.Lock() + if b.closed { + b.mu.Unlock() + sub.closeInput() + return nil, ErrBusClosed + } + b.subs[id] = sub + b.mu.Unlock() + + if handler != nil { + go sub.run(ctx) + } + sub.watchContext(ctx) + return sub, nil +} + +func (b *EventBus) unsubscribe(id uint64) { + b.mu.Lock() + sub, ok := b.subs[id] + if ok { + delete(b.subs, id) + } + b.mu.Unlock() + + if ok { + sub.closeInput() + } +} + +func (b *EventBus) snapshotSubscribers() ([]*eventSubscription, bool) { + b.mu.RLock() + defer b.mu.RUnlock() + + if b.closed { + return nil, true + } + + subs := make([]*eventSubscription, 0, len(b.subs)) + for _, sub := range b.subs { + subs = append(subs, sub) + } + sortSubscriptions(subs) + return subs, false +} + +func sortSubscriptions(subs []*eventSubscription) { + sort.Slice(subs, func(i, j int) bool { + if subs[i].opts.Priority == subs[j].opts.Priority { + return subs[i].id < subs[j].id + } + return subs[i].opts.Priority > subs[j].opts.Priority + }) +} + +func nextEventID() string { + id := globalEventSeq.Add(1) + return "evt-" + strconv.FormatUint(id, 10) +} diff --git a/pkg/events/channel.go b/pkg/events/channel.go new file mode 100644 index 000000000..9cf6d8d8c --- /dev/null +++ b/pkg/events/channel.go @@ -0,0 +1,75 @@ +package events + +import "context" + +// EventChannel is a filtered view over an EventBus. +type EventChannel interface { + Filter(filter Filter) EventChannel + OfKind(kinds ...Kind) EventChannel + KindPrefix(prefix string) EventChannel + Source(component string, names ...string) EventChannel + Scope(scope ScopeFilter) EventChannel + + Subscribe(ctx context.Context, opts SubscribeOptions, handler Handler) (Subscription, error) + SubscribeChan(ctx context.Context, opts SubscribeOptions) (Subscription, <-chan Event, error) + SubscribeOnce(ctx context.Context, opts SubscribeOptions, handler Handler) (Subscription, error) +} + +type eventChannel struct { + bus *EventBus + filters []Filter +} + +// Filter returns a new EventChannel with filter appended. +func (c eventChannel) Filter(filter Filter) EventChannel { + filters := append([]Filter(nil), c.filters...) + if filter != nil { + filters = append(filters, filter) + } + return eventChannel{bus: c.bus, filters: filters} +} + +// OfKind returns a new EventChannel matching any of kinds. +func (c eventChannel) OfKind(kinds ...Kind) EventChannel { + return c.Filter(MatchKind(kinds...)) +} + +// KindPrefix returns a new EventChannel matching events with the kind prefix. +func (c eventChannel) KindPrefix(prefix string) EventChannel { + return c.Filter(MatchKindPrefix(prefix)) +} + +// Source returns a new EventChannel matching source component and optional names. +func (c eventChannel) Source(component string, names ...string) EventChannel { + return c.Filter(MatchSource(component, names...)) +} + +// Scope returns a new EventChannel matching non-empty scope fields. +func (c eventChannel) Scope(scope ScopeFilter) EventChannel { + return c.Filter(MatchScope(scope)) +} + +// Subscribe registers handler for events matching this channel. +func (c eventChannel) Subscribe(ctx context.Context, opts SubscribeOptions, handler Handler) (Subscription, error) { + if handler == nil { + return nil, ErrNilHandler + } + return c.bus.subscribe(ctx, c.filters, opts, handler, false) +} + +// SubscribeChan registers a channel subscription for events matching this channel. +func (c eventChannel) SubscribeChan(ctx context.Context, opts SubscribeOptions) (Subscription, <-chan Event, error) { + sub, err := c.bus.subscribe(ctx, c.filters, opts, nil, false) + if err != nil { + return nil, nil, err + } + return sub, sub.(*eventSubscription).ch, nil +} + +// SubscribeOnce registers handler and closes the subscription after the first event. +func (c eventChannel) SubscribeOnce(ctx context.Context, opts SubscribeOptions, handler Handler) (Subscription, error) { + if handler == nil { + return nil, ErrNilHandler + } + return c.bus.subscribe(ctx, c.filters, opts, handler, true) +} diff --git a/pkg/events/doc.go b/pkg/events/doc.go new file mode 100644 index 000000000..dc2f55631 --- /dev/null +++ b/pkg/events/doc.go @@ -0,0 +1,3 @@ +// Package events provides the process-local runtime event bus used to observe +// PicoClaw components without coupling them to agent-specific event envelopes. +package events diff --git a/pkg/events/events_test.go b/pkg/events/events_test.go new file mode 100644 index 000000000..19b9df96d --- /dev/null +++ b/pkg/events/events_test.go @@ -0,0 +1,155 @@ +package events + +import ( + "context" + "testing" + "time" +) + +func TestPublishDeliversToMatchingSubscriber(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + _, ch, err := bus.Channel().OfKind(KindAgentTurnStart).SubscribeChan( + context.Background(), + SubscribeOptions{Name: "turn-starts", Buffer: 1}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + unmatched := bus.Publish(context.Background(), Event{Kind: KindAgentTurnEnd}) + if unmatched.Matched != 0 || unmatched.Delivered != 0 { + t.Fatalf("unmatched Publish = %+v, want no delivery", unmatched) + } + + result := bus.Publish(context.Background(), Event{Kind: KindAgentTurnStart}) + if result.Matched != 1 || result.Delivered != 1 || result.Dropped != 0 { + t.Fatalf("Publish = %+v, want one delivered event", result) + } + + evt := receiveEvent(t, ch) + if evt.Kind != KindAgentTurnStart { + t.Fatalf("event kind = %q, want %q", evt.Kind, KindAgentTurnStart) + } + if evt.ID == "" { + t.Fatal("event ID is empty") + } + if evt.Time.IsZero() { + t.Fatal("event Time is zero") + } +} + +func TestDropNewestIncrementsStats(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + sub, _, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "drop-newest", Buffer: 1, Backpressure: DropNewest}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + first := bus.Publish(context.Background(), Event{Kind: KindAgentTurnStart}) + if first.Delivered != 1 || first.Dropped != 0 { + t.Fatalf("first Publish = %+v, want one delivered event", first) + } + + second := bus.Publish(context.Background(), Event{Kind: KindAgentTurnEnd}) + if second.Delivered != 0 || second.Dropped != 1 { + t.Fatalf("second Publish = %+v, want one dropped event", second) + } + + if got := sub.Stats().Dropped; got != 1 { + t.Fatalf("subscription dropped = %d, want 1", got) + } + if got := bus.Stats().Dropped; got != 1 { + t.Fatalf("bus dropped = %d, want 1", got) + } +} + +func TestDropOldestKeepsNewestEvent(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + sub, ch, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "drop-oldest", Buffer: 1, Backpressure: DropOldest}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + bus.Publish(context.Background(), Event{Kind: Kind("test.old"), Payload: "old"}) + result := bus.Publish(context.Background(), Event{Kind: Kind("test.new"), Payload: "new"}) + if result.Delivered != 1 || result.Dropped != 1 { + t.Fatalf("Publish = %+v, want replacement delivery", result) + } + + evt := receiveEvent(t, ch) + if evt.Payload != "new" { + t.Fatalf("payload = %v, want new", evt.Payload) + } + if got := sub.Stats().Dropped; got != 1 { + t.Fatalf("subscription dropped = %d, want 1", got) + } +} + +func TestBlockRespectsContext(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + _, _, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "block", Buffer: 1, Backpressure: Block}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + first := bus.Publish(context.Background(), Event{Kind: Kind("test.first")}) + if first.Delivered != 1 { + t.Fatalf("first Publish = %+v, want one delivered event", first) + } + + ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond) + defer cancel() + + second := bus.Publish(ctx, Event{Kind: Kind("test.second")}) + if second.Blocked != 1 || second.Dropped != 1 || second.Delivered != 0 { + t.Fatalf("second Publish = %+v, want one blocked drop", second) + } +} + +func receiveEvent(t *testing.T, ch <-chan Event) Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("event channel closed before receive") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for event") + return Event{} + } +} + +func closeBus(t *testing.T, bus *EventBus) { + t.Helper() + + if err := bus.Close(); err != nil { + t.Fatalf("Close failed: %v", err) + } +} diff --git a/pkg/events/filter.go b/pkg/events/filter.go new file mode 100644 index 000000000..0af2c85c1 --- /dev/null +++ b/pkg/events/filter.go @@ -0,0 +1,131 @@ +package events + +import "strings" + +// Filter decides whether an event should pass through an EventChannel. +type Filter func(Event) bool + +// ScopeFilter matches selected non-empty fields against Event.Scope. +type ScopeFilter struct { + AgentID string + SessionKey string + TurnID string + Channel string + ChatID string + MessageID string +} + +// MatchKind matches events whose kind is in kinds. Empty kinds match all events. +func MatchKind(kinds ...Kind) Filter { + if len(kinds) == 0 { + return matchAll + } + + allowed := make(map[Kind]struct{}, len(kinds)) + for _, kind := range kinds { + allowed[kind] = struct{}{} + } + + return func(evt Event) bool { + _, ok := allowed[evt.Kind] + return ok + } +} + +// MatchKindPrefix matches events whose kind starts with prefix. +func MatchKindPrefix(prefix string) Filter { + if prefix == "" { + return matchAll + } + return func(evt Event) bool { + return strings.HasPrefix(evt.Kind.String(), prefix) + } +} + +// MatchSource matches events emitted by component and, optionally, one of names. +func MatchSource(component string, names ...string) Filter { + if component == "" && len(names) == 0 { + return matchAll + } + + allowedNames := make(map[string]struct{}, len(names)) + for _, name := range names { + allowedNames[name] = struct{}{} + } + + return func(evt Event) bool { + if component != "" && evt.Source.Component != component { + return false + } + if len(allowedNames) == 0 { + return true + } + _, ok := allowedNames[evt.Source.Name] + return ok + } +} + +// MatchScope matches events whose Scope contains all non-empty filter fields. +func MatchScope(scope ScopeFilter) Filter { + if scope == (ScopeFilter{}) { + return matchAll + } + + return func(evt Event) bool { + return matchesString(scope.AgentID, evt.Scope.AgentID) && + matchesString(scope.SessionKey, evt.Scope.SessionKey) && + matchesString(scope.TurnID, evt.Scope.TurnID) && + matchesString(scope.Channel, evt.Scope.Channel) && + matchesString(scope.ChatID, evt.Scope.ChatID) && + matchesString(scope.MessageID, evt.Scope.MessageID) + } +} + +// And combines filters and short-circuits on the first non-match. +func And(filters ...Filter) Filter { + if len(filters) == 0 { + return matchAll + } + + return func(evt Event) bool { + for _, filter := range filters { + if filter != nil && !filter(evt) { + return false + } + } + return true + } +} + +// Or combines filters and short-circuits on the first match. +func Or(filters ...Filter) Filter { + if len(filters) == 0 { + return matchAll + } + + return func(evt Event) bool { + for _, filter := range filters { + if filter == nil || filter(evt) { + return true + } + } + return false + } +} + +func matchAll(Event) bool { + return true +} + +func matchesString(want, got string) bool { + return want == "" || want == got +} + +func matchesFilters(filters []Filter, evt Event) bool { + for _, filter := range filters { + if filter != nil && !filter(evt) { + return false + } + } + return true +} diff --git a/pkg/events/filter_test.go b/pkg/events/filter_test.go new file mode 100644 index 000000000..9b0112754 --- /dev/null +++ b/pkg/events/filter_test.go @@ -0,0 +1,96 @@ +package events + +import "testing" + +func TestFilterKindPrefix(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + prefix string + event Event + want bool + }{ + { + name: "matches agent prefix", + prefix: "agent.", + event: Event{Kind: KindAgentTurnStart}, + want: true, + }, + { + name: "rejects different prefix", + prefix: "channel.", + event: Event{Kind: KindAgentTurnStart}, + want: false, + }, + { + name: "empty prefix matches all", + prefix: "", + event: Event{Kind: KindAgentTurnStart}, + want: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + if got := MatchKindPrefix(tt.prefix)(tt.event); got != tt.want { + t.Fatalf("MatchKindPrefix(%q) = %v, want %v", tt.prefix, got, tt.want) + } + }) + } +} + +func TestFilterScope(t *testing.T) { + t.Parallel() + + evt := Event{ + Scope: Scope{ + AgentID: "agent-a", + SessionKey: "session-1", + TurnID: "turn-1", + Channel: "telegram", + ChatID: "chat-1", + MessageID: "msg-1", + }, + } + + tests := []struct { + name string + scope ScopeFilter + want bool + }{ + { + name: "empty filter matches", + scope: ScopeFilter{}, + want: true, + }, + { + name: "matches selected fields", + scope: ScopeFilter{ + AgentID: "agent-a", + ChatID: "chat-1", + }, + want: true, + }, + { + name: "rejects mismatched field", + scope: ScopeFilter{ + AgentID: "agent-a", + MessageID: "msg-2", + }, + want: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + if got := MatchScope(tt.scope)(evt); got != tt.want { + t.Fatalf("MatchScope(%+v) = %v, want %v", tt.scope, got, tt.want) + } + }) + } +} diff --git a/pkg/events/kind.go b/pkg/events/kind.go new file mode 100644 index 000000000..86abfd55a --- /dev/null +++ b/pkg/events/kind.go @@ -0,0 +1,68 @@ +package events + +const ( + // KindAgentTurnStart is emitted when an agent turn starts. + KindAgentTurnStart Kind = "agent.turn.start" + // KindAgentTurnEnd is emitted when an agent turn ends. + KindAgentTurnEnd Kind = "agent.turn.end" + + // KindAgentLLMRequest is emitted before an LLM request. + KindAgentLLMRequest Kind = "agent.llm.request" + // KindAgentLLMDelta is emitted for streaming LLM deltas. + KindAgentLLMDelta Kind = "agent.llm.delta" + // KindAgentLLMResponse is emitted after an LLM response. + KindAgentLLMResponse Kind = "agent.llm.response" + // KindAgentLLMRetry is emitted before retrying an LLM request. + KindAgentLLMRetry Kind = "agent.llm.retry" + + // KindAgentContextCompress is emitted when agent context is compressed. + KindAgentContextCompress Kind = "agent.context.compress" + // KindAgentSessionSummarize is emitted when session summarization completes. + KindAgentSessionSummarize Kind = "agent.session.summarize" + + // KindAgentToolExecStart is emitted before a tool executes. + KindAgentToolExecStart Kind = "agent.tool.exec_start" + // KindAgentToolExecEnd is emitted after a tool finishes. + KindAgentToolExecEnd Kind = "agent.tool.exec_end" + // KindAgentToolExecSkipped is emitted when a tool call is skipped. + KindAgentToolExecSkipped Kind = "agent.tool.exec_skipped" + + // KindAgentSteeringInjected is emitted when steering is injected into context. + KindAgentSteeringInjected Kind = "agent.steering.injected" + // KindAgentFollowUpQueued is emitted when async follow-up input is queued. + KindAgentFollowUpQueued Kind = "agent.follow_up.queued" + // KindAgentInterruptReceived is emitted when a turn interrupt is accepted. + KindAgentInterruptReceived Kind = "agent.interrupt.received" + + // KindAgentSubTurnSpawn is emitted when a sub-turn is spawned. + KindAgentSubTurnSpawn Kind = "agent.subturn.spawn" + // KindAgentSubTurnEnd is emitted when a sub-turn ends. + KindAgentSubTurnEnd Kind = "agent.subturn.end" + // KindAgentSubTurnResultDelivered is emitted when a sub-turn result is delivered. + KindAgentSubTurnResultDelivered Kind = "agent.subturn.result_delivered" + // KindAgentSubTurnOrphan is emitted when a sub-turn result cannot be delivered. + KindAgentSubTurnOrphan Kind = "agent.subturn.orphan" + // KindAgentError is emitted when agent execution reports an error. + KindAgentError Kind = "agent.error" + + // KindChannelLifecycleStarted is emitted when a channel starts. + KindChannelLifecycleStarted Kind = "channel.lifecycle.started" + // KindChannelLifecycleStartFailed is emitted when a channel fails to start. + KindChannelLifecycleStartFailed Kind = "channel.lifecycle.start_failed" + // KindChannelMessageOutboundSent is emitted when an outbound channel message is sent. + KindChannelMessageOutboundSent Kind = "channel.message.outbound_sent" + // KindChannelMessageOutboundFailed is emitted when an outbound channel message fails. + KindChannelMessageOutboundFailed Kind = "channel.message.outbound_failed" + + // KindGatewayReloadStarted is emitted when gateway reload starts. + KindGatewayReloadStarted Kind = "gateway.reload.started" + // KindGatewayReloadCompleted is emitted when gateway reload completes. + KindGatewayReloadCompleted Kind = "gateway.reload.completed" + // KindGatewayReloadFailed is emitted when gateway reload fails. + KindGatewayReloadFailed Kind = "gateway.reload.failed" + + // KindMCPServerConnected is emitted when an MCP server connects. + KindMCPServerConnected Kind = "mcp.server.connected" + // KindMCPServerFailed is emitted when an MCP server fails. + KindMCPServerFailed Kind = "mcp.server.failed" +) diff --git a/pkg/events/stats.go b/pkg/events/stats.go new file mode 100644 index 000000000..7931c5ef3 --- /dev/null +++ b/pkg/events/stats.go @@ -0,0 +1,26 @@ +package events + +// Stats reports aggregate EventBus counters. +type Stats struct { + Published uint64 + Matched uint64 + Delivered uint64 + Dropped uint64 + Blocked uint64 + Closed bool + Subscribers int + + SubscriberStats []SubscriberStats +} + +// SubscriberStats reports counters for one subscription. +type SubscriberStats struct { + ID uint64 + Name string + Received uint64 + Handled uint64 + Failed uint64 + Dropped uint64 + Panicked uint64 + TimedOut uint64 +} diff --git a/pkg/events/subscription.go b/pkg/events/subscription.go new file mode 100644 index 000000000..5ff47eddd --- /dev/null +++ b/pkg/events/subscription.go @@ -0,0 +1,384 @@ +package events + +import ( + "context" + "errors" + "log" + "sync" + "sync/atomic" + "time" +) + +const defaultSubscriberBuffer = 16 + +var ( + // ErrBusClosed is returned when subscribing to a closed event bus. + ErrBusClosed = errors.New("events: bus is closed") + // ErrNilHandler is returned when subscribing without a handler. + ErrNilHandler = errors.New("events: handler is nil") +) + +// Handler processes a runtime event delivered to a subscription. +type Handler func(context.Context, Event) error + +// SubscribeOptions controls how a subscription receives events. +type SubscribeOptions struct { + Name string + Buffer int + Priority int + Concurrency ConcurrencyKind + Backpressure BackpressurePolicy + Timeout time.Duration + PanicPolicy PanicPolicy +} + +// ConcurrencyKind controls how handler subscriptions process queued events. +type ConcurrencyKind string + +const ( + // Concurrent processes each event in its own goroutine. + Concurrent ConcurrencyKind = "concurrent" + // Locked processes events sequentially in subscription order. + Locked ConcurrencyKind = "locked" + // Keyed is reserved for keyed sequential processing and currently behaves as Locked. + Keyed ConcurrencyKind = "keyed" +) + +// BackpressurePolicy controls delivery when a subscription queue is full. +type BackpressurePolicy string + +const ( + // DropNewest drops the event being published when the queue is full. + DropNewest BackpressurePolicy = "drop_newest" + // DropOldest drops one queued event and enqueues the event being published. + DropOldest BackpressurePolicy = "drop_oldest" + // Block waits for queue capacity until Publish's context is canceled. + Block BackpressurePolicy = "block" +) + +// PanicPolicy controls handler panic behavior. +type PanicPolicy string + +const ( + // RecoverAndLog recovers handler panics and records them in subscription stats. + RecoverAndLog PanicPolicy = "recover_and_log" + // Crash lets handler panics propagate from the worker goroutine. + Crash PanicPolicy = "crash" +) + +// Subscription represents an active event subscription. +type Subscription interface { + ID() uint64 + Name() string + Close() error + Done() <-chan struct{} + Stats() SubscriberStats +} + +type subscriberCounters struct { + received atomic.Uint64 + handled atomic.Uint64 + failed atomic.Uint64 + dropped atomic.Uint64 + panicked atomic.Uint64 + timedOut atomic.Uint64 +} + +type eventSubscription struct { + bus *EventBus + id uint64 + name string + opts SubscribeOptions + filters []Filter + handler Handler + once bool + + ch chan Event + done chan struct{} + closing chan struct{} + + closeOnce sync.Once + doneOnce sync.Once + mu sync.RWMutex + closed bool + wg sync.WaitGroup + + counters subscriberCounters +} + +func normalizeSubscribeOptions(opts SubscribeOptions) SubscribeOptions { + if opts.Buffer <= 0 { + opts.Buffer = defaultSubscriberBuffer + } + if opts.Concurrency == "" { + opts.Concurrency = Locked + } + if opts.Backpressure == "" { + opts.Backpressure = DropNewest + } + if opts.PanicPolicy == "" { + opts.PanicPolicy = RecoverAndLog + } + return opts +} + +func newSubscription( + bus *EventBus, + id uint64, + filters []Filter, + opts SubscribeOptions, + handler Handler, + once bool, +) *eventSubscription { + opts = normalizeSubscribeOptions(opts) + return &eventSubscription{ + bus: bus, + id: id, + name: opts.Name, + opts: opts, + filters: append([]Filter(nil), filters...), + handler: handler, + once: once, + ch: make(chan Event, opts.Buffer), + done: make(chan struct{}), + closing: make(chan struct{}), + } +} + +// ID returns the subscription identifier. +func (s *eventSubscription) ID() uint64 { + if s == nil { + return 0 + } + return s.id +} + +// Name returns the subscription name. +func (s *eventSubscription) Name() string { + if s == nil { + return "" + } + return s.name +} + +// Close removes the subscription and closes its delivery channel. +func (s *eventSubscription) Close() error { + if s == nil || s.bus == nil { + return nil + } + s.bus.unsubscribe(s.id) + return nil +} + +// Done returns a channel closed after the subscription has stopped processing. +func (s *eventSubscription) Done() <-chan struct{} { + if s == nil { + ch := make(chan struct{}) + close(ch) + return ch + } + return s.done +} + +// Stats returns a snapshot of the subscription counters. +func (s *eventSubscription) Stats() SubscriberStats { + if s == nil { + return SubscriberStats{} + } + return SubscriberStats{ + ID: s.id, + Name: s.name, + Received: s.counters.received.Load(), + Handled: s.counters.handled.Load(), + Failed: s.counters.failed.Load(), + Dropped: s.counters.dropped.Load(), + Panicked: s.counters.panicked.Load(), + TimedOut: s.counters.timedOut.Load(), + } +} + +func (s *eventSubscription) run(ctx context.Context) { + defer func() { + s.wg.Wait() + s.closeDone() + }() + + for evt := range s.ch { + s.dispatch(ctx, evt) + if s.once { + _ = s.Close() + return + } + } +} + +func (s *eventSubscription) dispatch(ctx context.Context, evt Event) { + switch s.opts.Concurrency { + case Concurrent: + s.wg.Add(1) + go func() { + defer s.wg.Done() + s.handle(ctx, evt) + }() + case Keyed: + // TODO: replace this with keyed executors when runtime events need + // per-scope ordering with cross-scope concurrency. + s.handle(ctx, evt) + default: + s.handle(ctx, evt) + } +} + +func (s *eventSubscription) handle(ctx context.Context, evt Event) { + if ctx == nil { + ctx = context.Background() + } + if s.opts.Timeout > 0 { + var cancel context.CancelFunc + ctx, cancel = context.WithTimeout(ctx, s.opts.Timeout) + defer cancel() + } + + if s.opts.PanicPolicy != Crash { + defer func() { + if recovered := recover(); recovered != nil { + s.counters.panicked.Add(1) + log.Printf("events: subscriber %q recovered panic: %v", s.name, recovered) + } + }() + } + + err := s.handler(ctx, evt) + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + s.counters.timedOut.Add(1) + } + if err != nil { + s.counters.failed.Add(1) + return + } + s.counters.handled.Add(1) +} + +func (s *eventSubscription) watchContext(ctx context.Context) { + if ctx == nil { + return + } + + go func() { + select { + case <-ctx.Done(): + _ = s.Close() + case <-s.done: + } + }() +} + +func (s *eventSubscription) closeInput() { + s.closeOnce.Do(func() { + close(s.closing) + s.mu.Lock() + s.closed = true + close(s.ch) + s.mu.Unlock() + if s.handler == nil { + s.closeDone() + } + }) +} + +func (s *eventSubscription) closeDone() { + s.doneOnce.Do(func() { + close(s.done) + }) +} + +type deliveryResult struct { + delivered int + dropped int + blocked int + closed bool +} + +func (s *eventSubscription) enqueue(ctx context.Context, evt Event) deliveryResult { + if ctx == nil { + ctx = context.Background() + } + + s.mu.RLock() + defer s.mu.RUnlock() + + if s.closed { + return deliveryResult{closed: true} + } + + s.counters.received.Add(1) + + switch s.opts.Backpressure { + case DropOldest: + return s.enqueueDropOldest(evt) + case Block: + return s.enqueueBlock(ctx, evt) + default: + return s.enqueueDropNewest(evt) + } +} + +func (s *eventSubscription) enqueueDropNewest(evt Event) deliveryResult { + select { + case <-s.closing: + return deliveryResult{closed: true} + default: + } + + select { + case s.ch <- evt: + return deliveryResult{delivered: 1} + default: + s.counters.dropped.Add(1) + return deliveryResult{dropped: 1} + } +} + +func (s *eventSubscription) enqueueDropOldest(evt Event) deliveryResult { + select { + case <-s.closing: + return deliveryResult{closed: true} + default: + } + + select { + case s.ch <- evt: + return deliveryResult{delivered: 1} + default: + } + + dropped := 0 + select { + case <-s.ch: + s.counters.dropped.Add(1) + dropped = 1 + default: + } + + select { + case <-s.closing: + return deliveryResult{dropped: dropped, closed: true} + case s.ch <- evt: + return deliveryResult{delivered: 1, dropped: dropped} + default: + s.counters.dropped.Add(1) + return deliveryResult{dropped: dropped + 1} + } +} + +func (s *eventSubscription) enqueueBlock(ctx context.Context, evt Event) deliveryResult { + select { + case <-s.closing: + return deliveryResult{closed: true} + case s.ch <- evt: + return deliveryResult{delivered: 1} + case <-ctx.Done(): + s.counters.dropped.Add(1) + return deliveryResult{dropped: 1, blocked: 1} + } +} diff --git a/pkg/events/subscription_test.go b/pkg/events/subscription_test.go new file mode 100644 index 000000000..8cb5f58dc --- /dev/null +++ b/pkg/events/subscription_test.go @@ -0,0 +1,156 @@ +package events + +import ( + "context" + "sync/atomic" + "testing" + "time" +) + +func TestSubscribeOnceClosesAfterFirstEvent(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + var handled atomic.Uint64 + sub, err := bus.Channel().SubscribeOnce( + context.Background(), + SubscribeOptions{Name: "once", Buffer: 2}, + func(context.Context, Event) error { + handled.Add(1) + return nil + }, + ) + if err != nil { + t.Fatalf("SubscribeOnce failed: %v", err) + } + + bus.Publish(context.Background(), Event{Kind: KindAgentTurnStart}) + waitForSubscriptionDone(t, sub) + bus.Publish(context.Background(), Event{Kind: KindAgentTurnEnd}) + + if got := handled.Load(); got != 1 { + t.Fatalf("handled = %d, want 1", got) + } + if got := sub.Stats().Handled; got != 1 { + t.Fatalf("subscription handled = %d, want 1", got) + } +} + +func TestUnsubscribeClosesChannel(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + sub, ch, err := bus.Channel().SubscribeChan(context.Background(), SubscribeOptions{Name: "chan"}) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + if err := sub.Close(); err != nil { + t.Fatalf("Close failed: %v", err) + } + + select { + case _, ok := <-ch: + if ok { + t.Fatal("channel is open, want closed") + } + case <-time.After(time.Second): + t.Fatal("timed out waiting for channel close") + } + waitForSubscriptionDone(t, sub) +} + +func TestHandlerPanicRecovered(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + sub, err := bus.Channel().Subscribe( + context.Background(), + SubscribeOptions{Name: "panic", Buffer: 1}, + func(context.Context, Event) error { + panic("boom") + }, + ) + if err != nil { + t.Fatalf("Subscribe failed: %v", err) + } + + bus.Publish(context.Background(), Event{Kind: KindAgentError}) + waitForStat(t, func() uint64 { + return sub.Stats().Panicked + }, 1) +} + +func TestLockedHandlerProcessesSequentially(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + var active atomic.Int64 + var maxActive atomic.Int64 + sub, err := bus.Channel().Subscribe( + context.Background(), + SubscribeOptions{Name: "locked", Buffer: 8, Concurrency: Locked}, + func(context.Context, Event) error { + current := active.Add(1) + for { + currentMax := maxActive.Load() + if current <= currentMax || maxActive.CompareAndSwap(currentMax, current) { + break + } + } + time.Sleep(10 * time.Millisecond) + active.Add(-1) + return nil + }, + ) + if err != nil { + t.Fatalf("Subscribe failed: %v", err) + } + + for i := 0; i < 5; i++ { + bus.Publish(context.Background(), Event{Kind: KindAgentLLMDelta}) + } + waitForStat(t, func() uint64 { + return sub.Stats().Handled + }, 5) + + if got := maxActive.Load(); got != 1 { + t.Fatalf("max active handlers = %d, want 1", got) + } +} + +func waitForSubscriptionDone(t *testing.T, sub Subscription) { + t.Helper() + + select { + case <-sub.Done(): + case <-time.After(time.Second): + t.Fatal("timed out waiting for subscription to stop") + } +} + +func waitForStat(t *testing.T, stat func() uint64, want uint64) { + t.Helper() + + deadline := time.After(time.Second) + ticker := time.NewTicker(time.Millisecond) + defer ticker.Stop() + + for { + if got := stat(); got >= want { + return + } + select { + case <-ticker.C: + case <-deadline: + t.Fatalf("timed out waiting for stat >= %d", want) + } + } +} diff --git a/pkg/events/types.go b/pkg/events/types.go new file mode 100644 index 000000000..2cfc0eaac --- /dev/null +++ b/pkg/events/types.go @@ -0,0 +1,77 @@ +package events + +import "time" + +// Kind identifies a runtime event category. +type Kind string + +// String returns the string representation of the event kind. +func (k Kind) String() string { + return string(k) +} + +// Event is the runtime event envelope shared across PicoClaw components. +type Event struct { + ID string `json:"id"` + Kind Kind `json:"kind"` + Time time.Time `json:"time"` + Source Source `json:"source"` + Scope Scope `json:"scope,omitempty"` + Correlation Correlation `json:"correlation,omitempty"` + Severity Severity `json:"severity,omitempty"` + Payload any `json:"payload,omitempty"` + Attrs map[string]any `json:"attrs,omitempty"` +} + +// Source identifies the component that emitted an event. +type Source struct { + Component string `json:"component"` + Name string `json:"name,omitempty"` +} + +// Scope identifies the runtime ownership of an event. +// +// Scope is intentionally limited to agent, session, turn, channel, chat, +// message, and sender identity. Tool, provider, model, and MCP details belong +// in Source, Payload, or Attrs. +type Scope struct { + RuntimeID string `json:"runtime_id,omitempty"` + + AgentID string `json:"agent_id,omitempty"` + SessionKey string `json:"session_key,omitempty"` + TurnID string `json:"turn_id,omitempty"` + + Channel string `json:"channel,omitempty"` + Account string `json:"account,omitempty"` + ChatID string `json:"chat_id,omitempty"` + TopicID string `json:"topic_id,omitempty"` + + SpaceID string `json:"space_id,omitempty"` + SpaceType string `json:"space_type,omitempty"` + ChatType string `json:"chat_type,omitempty"` + + SenderID string `json:"sender_id,omitempty"` + MessageID string `json:"message_id,omitempty"` +} + +// Correlation carries cross-event tracing fields. +type Correlation struct { + TraceID string `json:"trace_id,omitempty"` + ParentTurnID string `json:"parent_turn_id,omitempty"` + RequestID string `json:"request_id,omitempty"` + ReplyToID string `json:"reply_to_id,omitempty"` +} + +// Severity describes the operational severity of an event. +type Severity string + +const ( + // SeverityDebug is used for verbose diagnostic events. + SeverityDebug Severity = "debug" + // SeverityInfo is used for normal lifecycle and activity events. + SeverityInfo Severity = "info" + // SeverityWarn is used for recoverable abnormal events. + SeverityWarn Severity = "warn" + // SeverityError is used for failed operations and unrecoverable events. + SeverityError Severity = "error" +) From 8caf9aeb2b3ffb97dd7f554f7b11b284f3b04116 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:05:10 +0800 Subject: [PATCH 14/53] feat(events): publish runtime service events Migrate hook observation to runtime events and update the process hook notification protocol. Add runtime event publication for message bus failures, channel lifecycle/outbound flow, gateway reloads, MCP server state, and MCP tool calls. Validation: go test ./pkg/events/... ./pkg/bus ./pkg/agent ./pkg/channels ./pkg/mcp ./pkg/tools/integration ./pkg/gateway; make lint --- docs/architecture/hooks/README.md | 41 ++--- docs/architecture/hooks/README.zh.md | 41 ++--- docs/architecture/hooks/hook-json-protocol.md | 39 ++-- .../hooks/hook-json-protocol.zh.md | 39 ++-- pkg/agent/agent_event.go | 8 + pkg/agent/agent_init.go | 2 +- pkg/agent/agent_mcp.go | 3 +- pkg/agent/hook_mount.go | 17 +- pkg/agent/hook_mount_test.go | 21 ++- pkg/agent/hook_process.go | 16 +- pkg/agent/hook_process_test.go | 8 +- pkg/agent/hooks.go | 106 ++++++++++- pkg/agent/hooks_test.go | 85 +++++++++ pkg/bus/bus.go | 48 ++++- pkg/bus/bus_test.go | 72 ++++++++ pkg/bus/events.go | 88 +++++++++ pkg/channels/events.go | 168 ++++++++++++++++++ pkg/channels/manager.go | 126 ++++++++++++- pkg/channels/manager_test.go | 124 +++++++++++++ pkg/events/kind.go | 29 +++ pkg/gateway/events.go | 46 +++++ pkg/gateway/gateway.go | 23 ++- pkg/mcp/events.go | 81 +++++++++ pkg/mcp/manager.go | 52 +++++- pkg/mcp/manager_test.go | 83 +++++++++ pkg/tools/integration/mcp_tool.go | 64 +++++++ pkg/tools/integration/mcp_tool_test.go | 68 +++++++ 27 files changed, 1394 insertions(+), 104 deletions(-) create mode 100644 pkg/bus/events.go create mode 100644 pkg/channels/events.go create mode 100644 pkg/gateway/events.go create mode 100644 pkg/mcp/events.go diff --git a/docs/architecture/hooks/README.md b/docs/architecture/hooks/README.md index 5be0f30b5..d9d5ece8f 100644 --- a/docs/architecture/hooks/README.md +++ b/docs/architecture/hooks/README.md @@ -13,7 +13,7 @@ The repository no longer ships standalone example source files. The Go and Pytho | Type | Interface | Stage | Can modify data | | --- | --- | --- | --- | -| Observer | `EventObserver` | EventBus broadcast | No | +| Observer | `RuntimeEventObserver` / `EventObserver` | Runtime event bus broadcast | No | | LLM interceptor | `LLMInterceptor` | `before_llm` / `after_llm` | Yes | | Tool interceptor | `ToolInterceptor` | `before_tool` / `after_tool` | Yes | | Tool approver | `ToolApprover` | `approve_tool` | No, returns allow/deny | @@ -136,9 +136,9 @@ Example: "/tmp/review_gate.py" ], "observe": [ - "tool_exec_start", - "tool_exec_end", - "tool_exec_skipped" + "agent.tool.exec_start", + "agent.tool.exec_end", + "agent.tool.exec_skipped" ], "intercept": [ "before_tool", @@ -174,7 +174,7 @@ Both examples are intentionally safe: they only log, never rewrite, and never de The following is a minimal logging hook for in-process use. It implements: -1. `EventObserver` +1. `RuntimeEventObserver` 2. `LLMInterceptor` 3. `ToolInterceptor` 4. `ToolApprover` @@ -196,6 +196,7 @@ import ( "time" "github.com/sipeed/picoclaw/pkg/agent" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" ) @@ -217,12 +218,12 @@ func NewExampleLoggerHook(opts ExampleLoggerHookOptions) *ExampleLoggerHook { } } -func (h *ExampleLoggerHook) OnEvent(ctx context.Context, evt agent.Event) error { +func (h *ExampleLoggerHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { _ = ctx if h == nil || !h.logEvents { return nil } - h.record("event", evt.Meta, map[string]any{ + h.record("event", evt.Scope, map[string]any{ "event": evt.Kind.String(), "payload": evt.Payload, }, nil) @@ -275,7 +276,7 @@ func (h *ExampleLoggerHook) ApproveTool( return decision, nil } -func (h *ExampleLoggerHook) record(stage string, meta agent.EventMeta, payload any, decision any) { +func (h *ExampleLoggerHook) record(stage string, refs any, payload any, decision any) { logger.InfoCF("hooks", "Example hook observed", map[string]any{ "stage": stage, }) @@ -286,7 +287,7 @@ func (h *ExampleLoggerHook) record(stage string, meta agent.EventMeta, payload a entry := map[string]any{ "ts": time.Now().UTC(), "stage": stage, - "meta": meta, + "refs": refs, "payload": payload, "decision": decision, } @@ -428,7 +429,7 @@ If you only see `before_llm` and `after_llm`, that usually means the request did The following script is a minimal process-hook example. It uses only the Python standard library and supports: 1. `hook.hello` -2. `hook.event` +2. `hook.runtime_event` 3. `hook.before_tool` 4. `hook.approve_tool` @@ -564,8 +565,8 @@ def main() -> int: }) if not message_id: - if method == "hook.event" and LOG_EVENTS: - log_stderr(f"observed event: {params.get('Kind')}") + if method == "hook.runtime_event" and LOG_EVENTS: + log_stderr(f"observed event: {params.get('kind')}") continue try: @@ -606,9 +607,9 @@ if __name__ == "__main__": "/abs/path/to/review_gate.py" ], "observe": [ - "tool_exec_start", - "tool_exec_end", - "tool_exec_skipped" + "agent.tool.exec_start", + "agent.tool.exec_end", + "agent.tool.exec_skipped" ], "intercept": [ "before_tool", @@ -626,7 +627,7 @@ if __name__ == "__main__": ### Environment Variables - `PICOCLAW_HOOK_LOG_EVENTS` - Whether to write `hook.event` summaries to `stderr`, enabled by default + Whether to write `hook.runtime_event` summaries to `stderr`, enabled by default - `PICOCLAW_HOOK_LOG_FILE` Path to an external log file. When set, the script appends inbound hook requests, notifications, and outbound responses as JSON Lines @@ -645,7 +646,7 @@ Typical interpretation: - Only `hook.hello` The process started and completed the handshake, but no business hook request has arrived yet -- `hook.event` +- `hook.runtime_event` The `observe` configuration is working - `hook.before_tool` The `intercept: ["before_tool", ...]` configuration is working @@ -664,7 +665,7 @@ A complete sample: ```json {"ts":"2026-03-21T14:12:00+00:00","direction":"in","id":1,"method":"hook.hello","params":{"name":"py_review_gate","version":1,"modes":["observe","tool","approve"]},"notification":false} {"ts":"2026-03-21T14:12:00+00:00","direction":"out","id":1,"response":{"ok":true,"name":"python-review-gate"},"error":null} -{"ts":"2026-03-21T14:12:05+00:00","direction":"in","id":0,"method":"hook.event","params":{"Kind":"tool_exec_start"},"notification":true} +{"ts":"2026-03-21T14:12:05+00:00","direction":"in","id":0,"method":"hook.runtime_event","params":{"kind":"agent.tool.exec_start"},"notification":true} {"ts":"2026-03-21T14:12:05+00:00","direction":"in","id":7,"method":"hook.before_tool","params":{"tool":"echo_text","arguments":{"text":"hello"}},"notification":false} {"ts":"2026-03-21T14:12:05+00:00","direction":"out","id":7,"response":{"action":"continue"},"error":null} ``` @@ -672,7 +673,7 @@ A complete sample: Additional notes: - Timestamps are UTC -- `notification=true` means it was a notification such as `hook.event`, which does not expect a response +- `notification=true` means it was a notification such as `hook.runtime_event`, which does not expect a response - `id` increases within a single hook process; if the process restarts, the counter starts over ## Process-Hook Protocol @@ -681,7 +682,7 @@ Current process hooks use `JSON-RPC over stdio`: - PicoClaw starts the external process - Requests and responses are exchanged as one JSON message per line -- `hook.event` is a notification and does not need a response +- `hook.runtime_event` is a notification and does not need a response - `hook.before_llm`, `hook.after_llm`, `hook.before_tool`, `hook.after_tool`, and `hook.approve_tool` are request/response calls The host does not currently accept new RPCs initiated by the process hook. In practice, that means an external hook can only respond to PicoClaw calls; it cannot call back into the host to send channel messages. diff --git a/docs/architecture/hooks/README.zh.md b/docs/architecture/hooks/README.zh.md index 2170d45c8..b9d45b386 100644 --- a/docs/architecture/hooks/README.zh.md +++ b/docs/architecture/hooks/README.zh.md @@ -13,7 +13,7 @@ | 类型 | 接口 | 作用阶段 | 能否改写 | | --- | --- | --- | --- | -| 观察型 | `EventObserver` | EventBus 广播事件时 | 否 | +| 观察型 | `RuntimeEventObserver` / `EventObserver` | runtime event bus 广播事件时 | 否 | | LLM 拦截型 | `LLMInterceptor` | `before_llm` / `after_llm` | 是 | | Tool 拦截型 | `ToolInterceptor` | `before_tool` / `after_tool` | 是 | | Tool 审批型 | `ToolApprover` | `approve_tool` | 否，返回批准/拒绝 | @@ -136,9 +136,9 @@ HookManager 的排序规则是： "/tmp/review_gate.py" ], "observe": [ - "tool_exec_start", - "tool_exec_end", - "tool_exec_skipped" + "agent.tool.exec_start", + "agent.tool.exec_end", + "agent.tool.exec_skipped" ], "intercept": [ "before_tool", @@ -174,7 +174,7 @@ tail -f /tmp/picoclaw-hook-review-gate.log 下面这段代码是一个最小的“记录型” in-process hook。它实现了： -1. `EventObserver` +1. `RuntimeEventObserver` 2. `LLMInterceptor` 3. `ToolInterceptor` 4. `ToolApprover` @@ -196,6 +196,7 @@ import ( "time" "github.com/sipeed/picoclaw/pkg/agent" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" ) @@ -217,12 +218,12 @@ func NewExampleLoggerHook(opts ExampleLoggerHookOptions) *ExampleLoggerHook { } } -func (h *ExampleLoggerHook) OnEvent(ctx context.Context, evt agent.Event) error { +func (h *ExampleLoggerHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { _ = ctx if h == nil || !h.logEvents { return nil } - h.record("event", evt.Meta, map[string]any{ + h.record("event", evt.Scope, map[string]any{ "event": evt.Kind.String(), "payload": evt.Payload, }, nil) @@ -275,7 +276,7 @@ func (h *ExampleLoggerHook) ApproveTool( return decision, nil } -func (h *ExampleLoggerHook) record(stage string, meta agent.EventMeta, payload any, decision any) { +func (h *ExampleLoggerHook) record(stage string, refs any, payload any, decision any) { logger.InfoCF("hooks", "Example hook observed", map[string]any{ "stage": stage, }) @@ -286,7 +287,7 @@ func (h *ExampleLoggerHook) record(stage string, meta agent.EventMeta, payload a entry := map[string]any{ "ts": time.Now().UTC(), "stage": stage, - "meta": meta, + "refs": refs, "payload": payload, "decision": decision, } @@ -428,7 +429,7 @@ func init() { 下面这段脚本是一个最小的 `process hook` 示例。它只使用 Python 标准库，支持： 1. `hook.hello` -2. `hook.event` +2. `hook.runtime_event` 3. `hook.before_tool` 4. `hook.approve_tool` @@ -564,8 +565,8 @@ def main() -> int: }) if not message_id: - if method == "hook.event" and LOG_EVENTS: - log_stderr(f"observed event: {params.get('Kind')}") + if method == "hook.runtime_event" and LOG_EVENTS: + log_stderr(f"observed event: {params.get('kind')}") continue try: @@ -606,9 +607,9 @@ if __name__ == "__main__": "/abs/path/to/review_gate.py" ], "observe": [ - "tool_exec_start", - "tool_exec_end", - "tool_exec_skipped" + "agent.tool.exec_start", + "agent.tool.exec_end", + "agent.tool.exec_skipped" ], "intercept": [ "before_tool", @@ -626,7 +627,7 @@ if __name__ == "__main__": ### 环境变量 - `PICOCLAW_HOOK_LOG_EVENTS` - 是否把 `hook.event` 写到 `stderr`，默认开启 + 是否把 `hook.runtime_event` 写到 `stderr`，默认开启 - `PICOCLAW_HOOK_LOG_FILE` 外部日志文件路径。设置后，脚本会把收到的 hook 请求、notification 和返回结果按 JSON Lines 追加到该文件 @@ -645,7 +646,7 @@ if __name__ == "__main__": - 只看到 `hook.hello` 说明进程启动并完成握手了，但还没有新的业务 hook 请求真正打进来 -- 看到 `hook.event` +- 看到 `hook.runtime_event` 说明 `observe` 配置生效了 - 看到 `hook.before_tool` 说明 `intercept: ["before_tool", ...]` 生效了 @@ -664,7 +665,7 @@ if __name__ == "__main__": ```json {"ts":"2026-03-21T14:12:00+00:00","direction":"in","id":1,"method":"hook.hello","params":{"name":"py_review_gate","version":1,"modes":["observe","tool","approve"]},"notification":false} {"ts":"2026-03-21T14:12:00+00:00","direction":"out","id":1,"response":{"ok":true,"name":"python-review-gate"},"error":null} -{"ts":"2026-03-21T14:12:05+00:00","direction":"in","id":0,"method":"hook.event","params":{"Kind":"tool_exec_start"},"notification":true} +{"ts":"2026-03-21T14:12:05+00:00","direction":"in","id":0,"method":"hook.runtime_event","params":{"kind":"agent.tool.exec_start"},"notification":true} {"ts":"2026-03-21T14:12:05+00:00","direction":"in","id":7,"method":"hook.before_tool","params":{"tool":"echo_text","arguments":{"text":"hello"}},"notification":false} {"ts":"2026-03-21T14:12:05+00:00","direction":"out","id":7,"response":{"action":"continue"},"error":null} ``` @@ -672,7 +673,7 @@ if __name__ == "__main__": 补充说明： - 时间戳是 UTC，不是本地时区 -- `notification=true` 表示这是 `hook.event` 这类不需要响应的通知 +- `notification=true` 表示这是 `hook.runtime_event` 这类不需要响应的通知 - `id` 会随着当前进程内的请求递增；如果 hook 进程重启，计数会重新开始 ## Process Hook 协议约定 @@ -681,7 +682,7 @@ if __name__ == "__main__": - PicoClaw 启动外部进程 - 请求和响应都按“一行一个 JSON 消息”传输 -- `hook.event` 是 notification，不需要响应 +- `hook.runtime_event` 是 notification，不需要响应 - `hook.before_llm` / `hook.after_llm` / `hook.before_tool` / `hook.after_tool` / `hook.approve_tool` 是 request/response 当前宿主不会接受 process hook 主动发起的新 RPC。也就是说，外部 hook 现在只能“响应 PicoClaw 的调用”，不能反向调用宿主去发送 channel 消息。 diff --git a/docs/architecture/hooks/hook-json-protocol.md b/docs/architecture/hooks/hook-json-protocol.md index 58b6e323b..725869a02 100644 --- a/docs/architecture/hooks/hook-json-protocol.md +++ b/docs/architecture/hooks/hook-json-protocol.md @@ -437,21 +437,28 @@ Approval hook for deciding whether to allow execution of sensitive tools. --- -## 7. `hook.event` (notification) +## 7. `hook.runtime_event` (notification) -Observer event, broadcast only, no response required. `id` is `0` or absent. +Runtime observer event, broadcast only, no response required. `id` is `0` or absent. ```json { "jsonrpc": "2.0", - "method": "hook.event", + "method": "hook.runtime_event", "params": { - "Kind": "tool_exec_start", - "Meta": { - "AgentID": "agent-1", - "TurnID": "turn-1" + "kind": "agent.tool.exec_start", + "source": { + "component": "agent", + "name": "agent-1" }, - "Payload": { + "scope": { + "agent_id": "agent-1", + "session_key": "session-1", + "turn_id": "turn-1", + "channel": "cli", + "chat_id": "chat-1" + }, + "payload": { "Tool": "echo_text", "Arguments": {"text": "hello"} } @@ -460,12 +467,14 @@ Observer event, broadcast only, no response required. `id` is `0` or absent. ``` Common `Kind` values: -- `turn_start` / `turn_end` -- `llm_request` / `llm_response` -- `tool_exec_start` / `tool_exec_end` / `tool_exec_skipped` -- `steering_injected` -- `interrupt_received` -- `error` +- `agent.turn.start` / `agent.turn.end` +- `agent.llm.request` / `agent.llm.response` +- `agent.tool.exec_start` / `agent.tool.exec_end` / `agent.tool.exec_skipped` +- `agent.steering.injected` +- `agent.interrupt.received` +- `agent.error` + +Legacy observe configuration names such as `turn_end` and `tool_exec_start` are still accepted and normalized to runtime event names. New process hook notifications use `hook.runtime_event`. --- @@ -565,4 +574,4 @@ def handle_before_tool(params: dict) -> dict: return {"action": "continue"} ``` -This way, external hooks can fully implement plugin tools without registering any tool implementation inside PicoClaw. \ No newline at end of file +This way, external hooks can fully implement plugin tools without registering any tool implementation inside PicoClaw. diff --git a/docs/architecture/hooks/hook-json-protocol.zh.md b/docs/architecture/hooks/hook-json-protocol.zh.md index 675e0a429..9c11c6270 100644 --- a/docs/architecture/hooks/hook-json-protocol.zh.md +++ b/docs/architecture/hooks/hook-json-protocol.zh.md @@ -437,21 +437,28 @@ --- -## 7. `hook.event`（notification） +## 7. `hook.runtime_event`（notification） -观察型事件，仅广播，无需响应。`id` 为 `0` 或不存在。 +runtime 观察型事件，仅广播，无需响应。`id` 为 `0` 或不存在。 ```json { "jsonrpc": "2.0", - "method": "hook.event", + "method": "hook.runtime_event", "params": { - "Kind": "tool_exec_start", - "Meta": { - "AgentID": "agent-1", - "TurnID": "turn-1" + "kind": "agent.tool.exec_start", + "source": { + "component": "agent", + "name": "agent-1" }, - "Payload": { + "scope": { + "agent_id": "agent-1", + "session_key": "session-1", + "turn_id": "turn-1", + "channel": "cli", + "chat_id": "chat-1" + }, + "payload": { "Tool": "echo_text", "Arguments": {"text": "hello"} } @@ -460,12 +467,14 @@ ``` 常见 `Kind` 值： -- `turn_start` / `turn_end` -- `llm_request` / `llm_response` -- `tool_exec_start` / `tool_exec_end` / `tool_exec_skipped` -- `steering_injected` -- `interrupt_received` -- `error` +- `agent.turn.start` / `agent.turn.end` +- `agent.llm.request` / `agent.llm.response` +- `agent.tool.exec_start` / `agent.tool.exec_end` / `agent.tool.exec_skipped` +- `agent.steering.injected` +- `agent.interrupt.received` +- `agent.error` + +旧 observe 配置名如 `turn_end`、`tool_exec_start` 仍然可用，并会归一化为 runtime event 名称。新的 process hook 通知使用 `hook.runtime_event`。 --- @@ -565,4 +574,4 @@ def handle_before_tool(params: dict) -> dict: return {"action": "continue"} ``` -通过这种方式，外部 hook 可以完全实现插件工具，无需在 PicoClaw 内部注册任何工具实现。 \ No newline at end of file +通过这种方式，外部 hook 可以完全实现插件工具，无需在 PicoClaw 内部注册任何工具实现。 diff --git a/pkg/agent/agent_event.go b/pkg/agent/agent_event.go index d634d8707..5ba6c579c 100644 --- a/pkg/agent/agent_event.go +++ b/pkg/agent/agent_event.go @@ -206,3 +206,11 @@ func (al *AgentLoop) RuntimeEventStats() runtimeevents.Stats { } return al.runtimeEvents.Stats() } + +// RuntimeEventBus returns the runtime event bus used by the agent loop. +func (al *AgentLoop) RuntimeEventBus() runtimeevents.Bus { + if al == nil { + return nil + } + return al.runtimeEvents +} diff --git a/pkg/agent/agent_init.go b/pkg/agent/agent_init.go index da2e79aa8..7ae844656 100644 --- a/pkg/agent/agent_init.go +++ b/pkg/agent/agent_init.go @@ -79,7 +79,7 @@ func NewAgentLoop( al.ownsRuntimeEvents = true } al.providerFactory = providers.CreateProviderFromConfig - al.hooks = NewHookManager(eventBus) + al.hooks = NewHookManagerWithRuntimeEvents(eventBus, al.runtimeEvents.Channel()) configureHookManagerFromConfig(al.hooks, cfg) al.contextManager = al.resolveContextManager() diff --git a/pkg/agent/agent_mcp.go b/pkg/agent/agent_mcp.go index fcb57a5d4..b3c69504b 100644 --- a/pkg/agent/agent_mcp.go +++ b/pkg/agent/agent_mcp.go @@ -97,7 +97,7 @@ func (al *AgentLoop) ensureMCPInitialized(ctx context.Context) error { } al.mcp.initOnce.Do(func() { - mcpManager := mcp.NewManager() + mcpManager := mcp.NewManager(mcp.WithRuntimeEvents(al.runtimeEvents)) defaultAgent := al.registry.GetDefaultAgent() workspacePath := al.cfg.WorkspacePath() @@ -164,6 +164,7 @@ func (al *AgentLoop) ensureMCPInitialized(ctx context.Context) error { mcpTool := tools.NewMCPTool(mcpManager, serverName, tool) mcpTool.SetWorkspace(agent.Workspace) mcpTool.SetMaxInlineTextRunes(al.cfg.Tools.MCP.GetMaxInlineTextChars()) + mcpTool.SetEventPublisher(al.runtimeEvents) if registerAsHidden { agent.Tools.RegisterHidden(mcpTool) diff --git a/pkg/agent/hook_mount.go b/pkg/agent/hook_mount.go index c92145f1f..dc002a508 100644 --- a/pkg/agent/hook_mount.go +++ b/pkg/agent/hook_mount.go @@ -8,6 +8,7 @@ import ( "time" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) type hookRuntime struct { @@ -295,10 +296,11 @@ func processHookObserveKindsFromConfig(observe []string) ([]string, bool, error) case "", "*", "all": return nil, true, nil default: - if _, ok := validKinds[kind]; !ok { + normalizedKind, ok := validKinds[kind] + if !ok { return nil, false, fmt.Errorf("unsupported observe event %q", kind) } - normalized = append(normalized, kind) + normalized = append(normalized, normalizedKind) } } @@ -308,10 +310,15 @@ func processHookObserveKindsFromConfig(observe []string) ([]string, bool, error) return normalized, true, nil } -func validHookEventKinds() map[string]struct{} { - kinds := make(map[string]struct{}, int(eventKindCount)) +func validHookEventKinds() map[string]string { + kinds := make(map[string]string, int(eventKindCount)*2) for kind := EventKind(0); kind < eventKindCount; kind++ { - kinds[kind.String()] = struct{}{} + runtimeKind := runtimeKindForAgentEvent(kind).String() + kinds[kind.String()] = runtimeKind + kinds[runtimeKind] = runtimeKind } + kinds[runtimeevents.KindAgentToolExecStart.String()] = runtimeevents.KindAgentToolExecStart.String() + kinds[runtimeevents.KindAgentToolExecEnd.String()] = runtimeevents.KindAgentToolExecEnd.String() + kinds[runtimeevents.KindAgentToolExecSkipped.String()] = runtimeevents.KindAgentToolExecSkipped.String() return kinds } diff --git a/pkg/agent/hook_mount_test.go b/pkg/agent/hook_mount_test.go index 85d8f5c11..bf98e6e03 100644 --- a/pkg/agent/hook_mount_test.go +++ b/pkg/agent/hook_mount_test.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "path/filepath" + "slices" "testing" "github.com/sipeed/picoclaw/pkg/bus" @@ -155,7 +156,25 @@ func TestAgentLoop_ProcessDirectWithChannel_AutoMountsProcessHook(t *testing.T) t.Fatalf("expected process model, got %q", lastModel) } - waitForFileContains(t, eventLog, "turn_end") + waitForFileContains(t, eventLog, "agent.turn.end") +} + +func TestProcessHookObserveKindsFromConfigAcceptsRuntimeNames(t *testing.T) { + kinds, enabled, err := processHookObserveKindsFromConfig([]string{ + "tool_exec_start", + "agent.tool.exec_end", + }) + if err != nil { + t.Fatalf("processHookObserveKindsFromConfig failed: %v", err) + } + if !enabled { + t.Fatal("expected observe to be enabled") + } + + want := []string{"agent.tool.exec_start", "agent.tool.exec_end"} + if !slices.Equal(kinds, want) { + t.Fatalf("observe kinds = %v, want %v", kinds, want) + } } func TestAgentLoop_ProcessDirectWithChannel_InvalidConfiguredHookFails(t *testing.T) { diff --git a/pkg/agent/hook_process.go b/pkg/agent/hook_process.go index ace95f44d..0ba5d8fc7 100644 --- a/pkg/agent/hook_process.go +++ b/pkg/agent/hook_process.go @@ -12,6 +12,7 @@ import ( "sync/atomic" "time" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/isolation" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/tools" @@ -188,13 +189,26 @@ func (ph *ProcessHook) OnEvent(ctx context.Context, evt Event) error { return nil } if len(ph.observeKinds) > 0 { - if _, ok := ph.observeKinds[evt.Kind.String()]; !ok { + kind := runtimeKindForAgentEvent(evt.Kind).String() + if _, ok := ph.observeKinds[kind]; !ok { return nil } } return ph.notify(ctx, "hook.event", evt) } +func (ph *ProcessHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { + if ph == nil || !ph.opts.Observe { + return nil + } + if len(ph.observeKinds) > 0 { + if _, ok := ph.observeKinds[evt.Kind.String()]; !ok { + return nil + } + } + return ph.notify(ctx, "hook.runtime_event", evt) +} + func (ph *ProcessHook) BeforeLLM( ctx context.Context, req *LLMHookRequest, diff --git a/pkg/agent/hook_process_test.go b/pkg/agent/hook_process_test.go index 9e95d105e..31f4ff7e4 100644 --- a/pkg/agent/hook_process_test.go +++ b/pkg/agent/hook_process_test.go @@ -66,7 +66,7 @@ func TestAgentLoop_MountProcessHook_LLMAndObserver(t *testing.T) { t.Fatalf("expected process model, got %q", lastModel) } - waitForFileContains(t, eventLog, "turn_end") + waitForFileContains(t, eventLog, "agent.turn.end") } func TestAgentLoop_MountProcessHook_ToolRewrite(t *testing.T) { @@ -350,10 +350,12 @@ func runProcessHookHelper() error { } if msg.ID == 0 { - if msg.Method == "hook.event" && eventLog != "" { + if (msg.Method == "hook.event" || msg.Method == "hook.runtime_event") && eventLog != "" { var evt map[string]any if err := json.Unmarshal(msg.Params, &evt); err == nil { - if rawKind, ok := evt["Kind"].(float64); ok { + if kind, ok := evt["kind"].(string); ok { + _ = os.WriteFile(eventLog, []byte(kind+"\n"), 0o644) + } else if rawKind, ok := evt["Kind"].(float64); ok { kind := EventKind(rawKind) _ = os.WriteFile(eventLog, []byte(kind.String()+"\n"), 0o644) } diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index 9cc3e6951..b84362fc1 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -9,6 +9,7 @@ import ( "sync" "time" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/tools" @@ -75,6 +76,10 @@ type EventObserver interface { OnEvent(ctx context.Context, evt Event) error } +type RuntimeEventObserver interface { + OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error +} + type LLMInterceptor interface { BeforeLLM(ctx context.Context, req *LLMHookRequest) (*LLMHookRequest, HookDecision, error) AfterLLM(ctx context.Context, resp *LLMHookResponse) (*LLMHookResponse, HookDecision, error) @@ -193,6 +198,7 @@ func (r *ToolResultHookResponse) Clone() *ToolResultHookResponse { type HookManager struct { eventBus *EventBus + runtimeEvents runtimeevents.EventChannel observerTimeout time.Duration interceptorTimeout time.Duration approvalTimeout time.Duration @@ -201,28 +207,56 @@ type HookManager struct { hooks map[string]HookRegistration ordered []HookRegistration - sub EventSubscription - done chan struct{} - closeOnce sync.Once + sub EventSubscription + runtimeSub runtimeevents.Subscription + done chan struct{} + runtimeDone chan struct{} + runtimeObserveEnabled bool + closeOnce sync.Once } func NewHookManager(eventBus *EventBus) *HookManager { + return NewHookManagerWithRuntimeEvents(eventBus, nil) +} + +func NewHookManagerWithRuntimeEvents(eventBus *EventBus, runtimeEvents runtimeevents.EventChannel) *HookManager { hm := &HookManager{ eventBus: eventBus, + runtimeEvents: runtimeEvents, observerTimeout: defaultHookObserverTimeout, interceptorTimeout: defaultHookInterceptorTimeout, approvalTimeout: defaultHookApprovalTimeout, hooks: make(map[string]HookRegistration), done: make(chan struct{}), + runtimeDone: make(chan struct{}), } - if eventBus == nil { + if eventBus != nil { + hm.sub = eventBus.Subscribe(hookObserverBufferSize) + go hm.dispatchEvents() + } else { close(hm.done) - return hm } - hm.sub = eventBus.Subscribe(hookObserverBufferSize) - go hm.dispatchEvents() + if runtimeEvents != nil { + sub, ch, err := runtimeEvents.SubscribeChan(context.Background(), runtimeevents.SubscribeOptions{ + Name: "hook-manager-observer", + Buffer: hookObserverBufferSize, + }) + if err != nil { + logger.WarnCF("hooks", "Failed to subscribe runtime events for hooks", map[string]any{ + "error": err.Error(), + }) + close(hm.runtimeDone) + } else { + hm.runtimeSub = sub + hm.runtimeObserveEnabled = true + go hm.dispatchRuntimeEvents(ch) + } + } else { + close(hm.runtimeDone) + } + return hm } @@ -235,7 +269,15 @@ func (hm *HookManager) Close() { if hm.eventBus != nil { hm.eventBus.Unsubscribe(hm.sub.ID) } + if hm.runtimeSub != nil { + if err := hm.runtimeSub.Close(); err != nil { + logger.WarnCF("hooks", "Failed to close runtime event hook subscription", map[string]any{ + "error": err.Error(), + }) + } + } <-hm.done + <-hm.runtimeDone hm.closeAllHooks() }) } @@ -297,6 +339,11 @@ func (hm *HookManager) dispatchEvents() { for evt := range hm.sub.C { for _, reg := range hm.snapshotHooks() { + if hm.runtimeObserveEnabled { + if _, ok := reg.Hook.(RuntimeEventObserver); ok { + continue + } + } observer, ok := reg.Hook.(EventObserver) if !ok { continue @@ -306,6 +353,20 @@ func (hm *HookManager) dispatchEvents() { } } +func (hm *HookManager) dispatchRuntimeEvents(ch <-chan runtimeevents.Event) { + defer close(hm.runtimeDone) + + for evt := range ch { + for _, reg := range hm.snapshotHooks() { + observer, ok := reg.Hook.(RuntimeEventObserver) + if !ok { + continue + } + hm.runRuntimeObserver(reg.Name, observer, evt) + } + } +} + func (hm *HookManager) BeforeLLM(ctx context.Context, req *LLMHookRequest) (*LLMHookRequest, HookDecision) { if hm == nil || req == nil { return req, HookDecision{Action: HookActionContinue} @@ -608,6 +669,37 @@ func (hm *HookManager) runObserver(name string, observer EventObserver, evt Even } } +func (hm *HookManager) runRuntimeObserver( + name string, + observer RuntimeEventObserver, + evt runtimeevents.Event, +) { + ctx, cancel := context.WithTimeout(context.Background(), hm.observerTimeout) + defer cancel() + + done := make(chan error, 1) + go func() { + done <- observer.OnRuntimeEvent(ctx, evt) + }() + + select { + case err := <-done: + if err != nil { + logger.WarnCF("hooks", "Runtime event observer failed", map[string]any{ + "hook": name, + "event": evt.Kind.String(), + "error": err.Error(), + }) + } + case <-ctx.Done(): + logger.WarnCF("hooks", "Runtime event observer timed out", map[string]any{ + "hook": name, + "event": evt.Kind.String(), + "timeout_ms": hm.observerTimeout.Milliseconds(), + }) + } +} + func (hm *HookManager) callBeforeLLM( parent context.Context, name string, diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index aa52bf2d5..d835cdc7d 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -12,6 +12,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" "github.com/sipeed/picoclaw/pkg/session" @@ -150,6 +151,31 @@ func (h *llmObserverHook) AfterLLM( return next, HookDecision{Action: HookActionModify}, nil } +type dualRuntimeObserverHook struct { + legacyCh chan Event + runtimeCh chan runtimeevents.Event +} + +func (h *dualRuntimeObserverHook) OnEvent(ctx context.Context, evt Event) error { + if evt.Kind == EventKindTurnEnd { + select { + case h.legacyCh <- evt: + default: + } + } + return nil +} + +func (h *dualRuntimeObserverHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { + if evt.Kind == runtimeevents.KindAgentTurnEnd { + select { + case h.runtimeCh <- evt: + default: + } + } + return nil +} + type llmSystemRewriteHook struct{} func (h *llmSystemRewriteHook) BeforeLLM( @@ -498,6 +524,65 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { } } +func TestAgentLoop_Hooks_RuntimeObserverPreferredOverLegacyObserver(t *testing.T) { + provider := &llmHookTestProvider{} + al, agent, cleanup := newHookTestLoop(t, provider) + defer cleanup() + + hook := &dualRuntimeObserverHook{ + legacyCh: make(chan Event, 1), + runtimeCh: make(chan runtimeevents.Event, 1), + } + if err := al.MountHook(NamedHook("runtime-observer", hook)); err != nil { + t.Fatalf("MountHook failed: %v", err) + } + + resp, err := al.runAgentLoop(context.Background(), agent, processOptions{ + SessionKey: "session-1", + Channel: "cli", + ChatID: "direct", + UserMessage: "hello", + DefaultResponse: defaultResponse, + EnableSummary: false, + SendResponse: false, + InboundContext: &bus.InboundContext{ + Channel: "cli", + Account: "default", + ChatID: "direct", + ChatType: "direct", + SenderID: "hook-user", + MessageID: "msg-1", + }, + }) + if err != nil { + t.Fatalf("runAgentLoop failed: %v", err) + } + if resp != "provider content" { + t.Fatalf("expected provider content, got %q", resp) + } + + select { + case evt := <-hook.runtimeCh: + if evt.Kind != runtimeevents.KindAgentTurnEnd { + t.Fatalf("runtime observer kind = %q", evt.Kind) + } + if evt.Scope.SessionKey != "session-1" || + evt.Scope.Channel != "cli" || + evt.Scope.ChatID != "direct" || + evt.Scope.MessageID != "msg-1" { + t.Fatalf("runtime observer scope = %+v", evt.Scope) + } + case <-time.After(2 * time.Second): + t.Fatal("timed out waiting for runtime observer event") + } + + select { + case evt := <-hook.legacyCh: + t.Fatalf("legacy observer unexpectedly received %v", evt.Kind) + case <-time.After(100 * time.Millisecond): + } +} + func TestAgentLoop_BtwCommand_UsesLLMHooks(t *testing.T) { provider := &llmHookTestProvider{} al, agent, cleanup := newHookTestLoop(t, provider) diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go index 9a05d4f95..fe01f31d5 100644 --- a/pkg/bus/bus.go +++ b/pkg/bus/bus.go @@ -6,6 +6,7 @@ import ( "sync" "sync/atomic" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" ) @@ -48,6 +49,12 @@ type MessageBus struct { closed atomic.Bool wg sync.WaitGroup streamDelegate atomic.Value // stores StreamDelegate + eventPublisher atomic.Value // stores EventPublisher +} + +// EventPublisher is the minimal runtime event publisher used by MessageBus. +type EventPublisher interface { + Publish(ctx context.Context, evt runtimeevents.Event) runtimeevents.PublishResult } func NewMessageBus() *MessageBus { @@ -92,9 +99,14 @@ func publish[T any](ctx context.Context, mb *MessageBus, ch chan T, msg T) error func (mb *MessageBus) PublishInbound(ctx context.Context, msg InboundMessage) error { msg = NormalizeInboundMessage(msg) if msg.Context.isZero() { + mb.publishFailure("inbound", runtimeScopeFromInboundContext(msg.Context), ErrMissingInboundContext) return ErrMissingInboundContext } - return publish(ctx, mb, mb.inbound, msg) + if err := publish(ctx, mb, mb.inbound, msg); err != nil { + mb.publishFailure("inbound", runtimeScopeFromInboundContext(msg.Context), err) + return err + } + return nil } func (mb *MessageBus) InboundChan() <-chan InboundMessage { @@ -104,9 +116,14 @@ func (mb *MessageBus) InboundChan() <-chan InboundMessage { func (mb *MessageBus) PublishOutbound(ctx context.Context, msg OutboundMessage) error { msg = NormalizeOutboundMessage(msg) if msg.Context.isZero() { + mb.publishFailure("outbound", runtimeScopeFromInboundContext(msg.Context), ErrMissingOutboundContext) return ErrMissingOutboundContext } - return publish(ctx, mb, mb.outbound, msg) + if err := publish(ctx, mb, mb.outbound, msg); err != nil { + mb.publishFailure("outbound", runtimeScopeFromInboundContext(msg.Context), err) + return err + } + return nil } func (mb *MessageBus) OutboundChan() <-chan OutboundMessage { @@ -116,9 +133,14 @@ func (mb *MessageBus) OutboundChan() <-chan OutboundMessage { func (mb *MessageBus) PublishOutboundMedia(ctx context.Context, msg OutboundMediaMessage) error { msg = NormalizeOutboundMediaMessage(msg) if msg.Context.isZero() { + mb.publishFailure("outbound_media", runtimeScopeFromInboundContext(msg.Context), ErrMissingOutboundMediaContext) return ErrMissingOutboundMediaContext } - return publish(ctx, mb, mb.outboundMedia, msg) + if err := publish(ctx, mb, mb.outboundMedia, msg); err != nil { + mb.publishFailure("outbound_media", runtimeScopeFromInboundContext(msg.Context), err) + return err + } + return nil } func (mb *MessageBus) OutboundMediaChan() <-chan OutboundMediaMessage { @@ -126,7 +148,11 @@ func (mb *MessageBus) OutboundMediaChan() <-chan OutboundMediaMessage { } func (mb *MessageBus) PublishAudioChunk(ctx context.Context, chunk AudioChunk) error { - return publish(ctx, mb, mb.audioChunks, chunk) + if err := publish(ctx, mb, mb.audioChunks, chunk); err != nil { + mb.publishFailure("audio_chunk", runtimeScopeFromAudioChunk(chunk), err) + return err + } + return nil } func (mb *MessageBus) AudioChunksChan() <-chan AudioChunk { @@ -134,7 +160,11 @@ func (mb *MessageBus) AudioChunksChan() <-chan AudioChunk { } func (mb *MessageBus) PublishVoiceControl(ctx context.Context, ctrl VoiceControl) error { - return publish(ctx, mb, mb.voiceControls, ctrl) + if err := publish(ctx, mb, mb.voiceControls, ctrl); err != nil { + mb.publishFailure("voice_control", runtimeScopeFromVoiceControl(ctrl), err) + return err + } + return nil } func (mb *MessageBus) VoiceControlsChan() <-chan VoiceControl { @@ -146,6 +176,11 @@ func (mb *MessageBus) SetStreamDelegate(d StreamDelegate) { mb.streamDelegate.Store(d) } +// SetEventPublisher registers a runtime event publisher for bus errors and lifecycle events. +func (mb *MessageBus) SetEventPublisher(p EventPublisher) { + mb.eventPublisher.Store(p) +} + // GetStreamer returns a Streamer for the given channel+chatID via the delegate. func (mb *MessageBus) GetStreamer(ctx context.Context, channel, chatID string) (Streamer, bool) { if d, ok := mb.streamDelegate.Load().(StreamDelegate); ok && d != nil { @@ -156,6 +191,7 @@ func (mb *MessageBus) GetStreamer(ctx context.Context, channel, chatID string) ( func (mb *MessageBus) Close() { mb.closeOnce.Do(func() { + mb.publishCloseEvent(runtimeevents.KindBusCloseStarted, 0) // notify all blocked publishers to exit close(mb.done) @@ -195,6 +231,8 @@ func (mb *MessageBus) Close() { logger.DebugCF("bus", "Drained buffered messages during close", map[string]any{ "count": drained, }) + mb.publishCloseEvent(runtimeevents.KindBusCloseDrained, drained) } + mb.publishCloseEvent(runtimeevents.KindBusCloseCompleted, drained) }) } diff --git a/pkg/bus/bus_test.go b/pkg/bus/bus_test.go index 5145d4759..e3abdc0e6 100644 --- a/pkg/bus/bus_test.go +++ b/pkg/bus/bus_test.go @@ -5,6 +5,8 @@ import ( "sync" "testing" "time" + + runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) func TestPublishConsume(t *testing.T) { @@ -171,6 +173,76 @@ func TestPublishInbound_BackfillsContextFromLegacyFields(t *testing.T) { } } +func TestMessageBusPublishesRuntimeFailureAndCloseEvents(t *testing.T) { + eventBus := runtimeevents.NewBus() + defer func() { + if err := eventBus.Close(); err != nil { + t.Errorf("event bus close failed: %v", err) + } + }() + + _, eventsCh, err := eventBus.Channel().OfKind( + runtimeevents.KindBusPublishFailed, + runtimeevents.KindBusCloseStarted, + runtimeevents.KindBusCloseDrained, + runtimeevents.KindBusCloseCompleted, + ).SubscribeChan(t.Context(), runtimeevents.SubscribeOptions{Name: "bus-events", Buffer: 4}) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + mb := NewMessageBus() + mb.SetEventPublisher(eventBus) + + if err := mb.PublishInbound(context.Background(), InboundMessage{}); err == nil { + t.Fatal("expected PublishInbound to fail") + } + failed := receiveBusRuntimeEvent(t, eventsCh) + if failed.Kind != runtimeevents.KindBusPublishFailed || + failed.Source.Name != "inbound" || + failed.Severity != runtimeevents.SeverityError { + t.Fatalf("publish failed event = %+v", failed) + } + + if err := mb.PublishOutbound(context.Background(), OutboundMessage{ + Context: NewOutboundContext("telegram", "chat-1", ""), + Content: "queued", + }); err != nil { + t.Fatalf("PublishOutbound failed: %v", err) + } + mb.Close() + + seen := map[runtimeevents.Kind]bool{} + for range 3 { + evt := receiveBusRuntimeEvent(t, eventsCh) + seen[evt.Kind] = true + } + for _, kind := range []runtimeevents.Kind{ + runtimeevents.KindBusCloseStarted, + runtimeevents.KindBusCloseDrained, + runtimeevents.KindBusCloseCompleted, + } { + if !seen[kind] { + t.Fatalf("missing %s event, seen=%v", kind, seen) + } + } +} + +func receiveBusRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("runtime event channel closed before expected event") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for runtime event") + return runtimeevents.Event{} + } +} + func TestPublishOutboundSubscribe(t *testing.T) { mb := NewMessageBus() defer mb.Close() diff --git a/pkg/bus/events.go b/pkg/bus/events.go new file mode 100644 index 000000000..c542892a1 --- /dev/null +++ b/pkg/bus/events.go @@ -0,0 +1,88 @@ +package bus + +import ( + "context" + "time" + + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +const busEventPublishTimeout = 100 * time.Millisecond + +type busPublishFailedPayload struct { + Stream string `json:"stream"` + Error string `json:"error"` +} + +type busClosePayload struct { + Drained int `json:"drained,omitempty"` +} + +func (mb *MessageBus) publishFailure(stream string, scope runtimeevents.Scope, err error) { + if mb == nil || err == nil { + return + } + publisher, ok := mb.eventPublisher.Load().(EventPublisher) + if !ok || publisher == nil { + return + } + + ctx, cancel := context.WithTimeout(context.Background(), busEventPublishTimeout) + defer cancel() + publisher.Publish(ctx, runtimeevents.Event{ + Kind: runtimeevents.KindBusPublishFailed, + Source: runtimeevents.Source{Component: "bus", Name: stream}, + Scope: scope, + Severity: runtimeevents.SeverityError, + Payload: busPublishFailedPayload{ + Stream: stream, + Error: err.Error(), + }, + }) +} + +func (mb *MessageBus) publishCloseEvent(kind runtimeevents.Kind, drained int) { + if mb == nil { + return + } + publisher, ok := mb.eventPublisher.Load().(EventPublisher) + if !ok || publisher == nil { + return + } + + ctx, cancel := context.WithTimeout(context.Background(), busEventPublishTimeout) + defer cancel() + publisher.Publish(ctx, runtimeevents.Event{ + Kind: kind, + Source: runtimeevents.Source{Component: "bus"}, + Severity: runtimeevents.SeverityInfo, + Payload: busClosePayload{Drained: drained}, + }) +} + +func runtimeScopeFromInboundContext(ctx InboundContext) runtimeevents.Scope { + return runtimeevents.Scope{ + Channel: ctx.Channel, + Account: ctx.Account, + ChatID: ctx.ChatID, + TopicID: ctx.TopicID, + SpaceID: ctx.SpaceID, + SpaceType: ctx.SpaceType, + ChatType: ctx.ChatType, + SenderID: ctx.SenderID, + MessageID: ctx.MessageID, + } +} + +func runtimeScopeFromAudioChunk(chunk AudioChunk) runtimeevents.Scope { + return runtimeevents.Scope{ + Channel: chunk.Channel, + ChatID: chunk.ChatID, + } +} + +func runtimeScopeFromVoiceControl(ctrl VoiceControl) runtimeevents.Scope { + return runtimeevents.Scope{ + ChatID: ctrl.ChatID, + } +} diff --git a/pkg/channels/events.go b/pkg/channels/events.go new file mode 100644 index 000000000..f731b84c5 --- /dev/null +++ b/pkg/channels/events.go @@ -0,0 +1,168 @@ +package channels + +import ( + "context" + "time" + + "github.com/sipeed/picoclaw/pkg/bus" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +const channelEventPublishTimeout = 100 * time.Millisecond + +func channelTypeForEvent(m *Manager, channelName string) string { + if m == nil || m.config == nil { + return channelName + } + if bc := m.config.Channels.Get(channelName); bc != nil && bc.Type != "" { + return bc.Type + } + return channelName +} + +func (m *Manager) publishChannelEvent( + kind runtimeevents.Kind, + channelName string, + scope runtimeevents.Scope, + severity runtimeevents.Severity, + payload any, +) { + if m == nil || m.runtimeEvents == nil { + return + } + if scope.Channel == "" { + scope.Channel = channelName + } + ctx, cancel := context.WithTimeout(context.Background(), channelEventPublishTimeout) + defer cancel() + m.runtimeEvents.Publish(ctx, runtimeevents.Event{ + Kind: kind, + Source: runtimeevents.Source{Component: "channel", Name: channelName}, + Scope: scope, + Severity: severity, + Payload: payload, + }) +} + +func (m *Manager) publishOutboundSent( + channelName string, + msg bus.OutboundMessage, + messageIDs []string, +) { + m.publishChannelEvent( + runtimeevents.KindChannelMessageOutboundSent, + channelName, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityInfo, + ChannelOutboundPayload{ + ContentLen: len([]rune(msg.Content)), + MessageIDs: append([]string(nil), messageIDs...), + ReplyToMessageID: msg.ReplyToMessageID, + }, + ) +} + +func (m *Manager) publishOutboundQueued( + channelName string, + msg bus.OutboundMessage, +) { + m.publishChannelEvent( + runtimeevents.KindChannelMessageOutboundQueued, + channelName, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityInfo, + ChannelOutboundPayload{ + ContentLen: len([]rune(msg.Content)), + ReplyToMessageID: msg.ReplyToMessageID, + }, + ) +} + +func (m *Manager) publishOutboundFailed( + channelName string, + msg bus.OutboundMessage, + err error, + media bool, +) { + payload := ChannelOutboundPayload{ + Media: media, + ContentLen: len([]rune(msg.Content)), + ReplyToMessageID: msg.ReplyToMessageID, + Retries: maxRetries, + } + if err != nil { + payload.Error = err.Error() + } + m.publishChannelEvent( + runtimeevents.KindChannelMessageOutboundFailed, + channelName, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityError, + payload, + ) +} + +func (m *Manager) publishOutboundMediaSent( + channelName string, + msg bus.OutboundMediaMessage, + messageIDs []string, +) { + m.publishChannelEvent( + runtimeevents.KindChannelMessageOutboundSent, + channelName, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityInfo, + ChannelOutboundPayload{ + Media: true, + MessageIDs: append([]string(nil), messageIDs...), + }, + ) +} + +func (m *Manager) publishOutboundMediaQueued( + channelName string, + msg bus.OutboundMediaMessage, +) { + m.publishChannelEvent( + runtimeevents.KindChannelMessageOutboundQueued, + channelName, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityInfo, + ChannelOutboundPayload{Media: true}, + ) +} + +func (m *Manager) publishOutboundMediaFailed( + channelName string, + msg bus.OutboundMediaMessage, + err error, +) { + payload := ChannelOutboundPayload{ + Media: true, + Retries: maxRetries, + } + if err != nil { + payload.Error = err.Error() + } + m.publishChannelEvent( + runtimeevents.KindChannelMessageOutboundFailed, + channelName, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityError, + payload, + ) +} + +func scopeFromOutboundContext(ctx bus.InboundContext) runtimeevents.Scope { + return runtimeevents.Scope{ + Channel: ctx.Channel, + Account: ctx.Account, + ChatID: ctx.ChatID, + TopicID: ctx.TopicID, + SpaceID: ctx.SpaceID, + SpaceType: ctx.SpaceType, + ChatType: ctx.ChatType, + SenderID: ctx.SenderID, + MessageID: ctx.MessageID, + } +} diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go index 7974a39e4..f083d83e9 100644 --- a/pkg/channels/manager.go +++ b/pkg/channels/manager.go @@ -23,6 +23,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" "github.com/sipeed/picoclaw/pkg/constants" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/health" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/media" @@ -84,6 +85,7 @@ type Manager struct { channels map[string]Channel workers map[string]*channelWorker bus *bus.MessageBus + runtimeEvents runtimeevents.Bus config *config.Config mediaStore media.MediaStore dispatchTask *asyncTask @@ -98,6 +100,32 @@ type Manager struct { channelHashes map[string]string // channel name → config hash } +// ManagerOption configures a channel Manager. +type ManagerOption func(*Manager) + +// WithRuntimeEvents injects the runtime event bus used for channel observations. +func WithRuntimeEvents(eventBus runtimeevents.Bus) ManagerOption { + return func(m *Manager) { + m.runtimeEvents = eventBus + } +} + +// ChannelLifecyclePayload describes channel lifecycle runtime events. +type ChannelLifecyclePayload struct { + Type string `json:"type,omitempty"` + Error string `json:"error,omitempty"` +} + +// ChannelOutboundPayload describes channel outbound message runtime events. +type ChannelOutboundPayload struct { + Media bool `json:"media,omitempty"` + ContentLen int `json:"content_len,omitempty"` + MessageIDs []string `json:"message_ids,omitempty"` + ReplyToMessageID string `json:"reply_to_message_id,omitempty"` + Error string `json:"error,omitempty"` + Retries int `json:"retries,omitempty"` +} + type toolFeedbackMessageTracker interface { RecordToolFeedbackMessage(chatID, messageID, content string) ClearToolFeedbackMessage(chatID string) @@ -395,7 +423,12 @@ func (m *Manager) preSendMedia(ctx context.Context, name string, msg bus.Outboun } } -func NewManager(cfg *config.Config, messageBus *bus.MessageBus, store media.MediaStore) (*Manager, error) { +func NewManager( + cfg *config.Config, + messageBus *bus.MessageBus, + store media.MediaStore, + opts ...ManagerOption, +) (*Manager, error) { m := &Manager{ channels: make(map[string]Channel), workers: make(map[string]*channelWorker), @@ -404,6 +437,11 @@ func NewManager(cfg *config.Config, messageBus *bus.MessageBus, store media.Medi mediaStore: store, channelHashes: make(map[string]string), } + for _, opt := range opts { + if opt != nil { + opt(m) + } + } // Register as streaming delegate so the agent loop can obtain streamers messageBus.SetStreamDelegate(m) @@ -528,6 +566,13 @@ func (m *Manager) initChannel(typeName, channelName string) { setter.SetOwner(ch) } m.channels[channelName] = ch + m.publishChannelEvent( + runtimeevents.KindChannelLifecycleInitialized, + channelName, + runtimeevents.Scope{Channel: channelName}, + runtimeevents.SeverityInfo, + ChannelLifecyclePayload{Type: typeName}, + ) logger.InfoCF("channels", "Channel enabled successfully", map[string]any{ "channel": channelName, "type": typeName, @@ -673,6 +718,13 @@ func (m *Manager) registerHTTPHandlersLocked() { func (m *Manager) registerChannelHTTPHandler(name string, ch Channel) { if wh, ok := ch.(WebhookHandler); ok { m.mux.Handle(wh.WebhookPath(), wh) + m.publishChannelEvent( + runtimeevents.KindChannelWebhookRegistered, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityInfo, + ChannelLifecyclePayload{Type: channelTypeForEvent(m, name)}, + ) logger.InfoCF("channels", "Webhook handler registered", map[string]any{ "channel": name, "path": wh.WebhookPath(), @@ -692,6 +744,13 @@ func (m *Manager) registerChannelHTTPHandler(name string, ch Channel) { func (m *Manager) unregisterChannelHTTPHandler(name string, ch Channel) { if wh, ok := ch.(WebhookHandler); ok { m.mux.Unhandle(wh.WebhookPath()) + m.publishChannelEvent( + runtimeevents.KindChannelWebhookUnregistered, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityInfo, + ChannelLifecyclePayload{Type: channelTypeForEvent(m, name)}, + ) logger.InfoCF("channels", "Webhook handler unregistered", map[string]any{ "channel": name, "path": wh.WebhookPath(), @@ -730,6 +789,13 @@ func (m *Manager) StartAll(ctx context.Context) error { "channel": name, "error": err.Error(), }) + m.publishChannelEvent( + runtimeevents.KindChannelLifecycleStartFailed, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityError, + ChannelLifecyclePayload{Type: channelTypeForEvent(m, name), Error: err.Error()}, + ) failedStarts = append(failedStarts, fmt.Errorf("channel %s: %w", name, err)) failedNames = append(failedNames, name) continue @@ -745,6 +811,13 @@ func (m *Manager) StartAll(ctx context.Context) error { m.workers[name] = w go m.runWorker(dispatchCtx, name, w) go m.runMediaWorker(dispatchCtx, name, w) + m.publishChannelEvent( + runtimeevents.KindChannelLifecycleStarted, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityInfo, + ChannelLifecyclePayload{Type: channelType}, + ) } if len(m.channels) > 0 && len(m.workers) == 0 { @@ -881,7 +954,15 @@ func (m *Manager) StopAll(ctx context.Context) error { "channel": name, "error": err.Error(), }) + continue } + m.publishChannelEvent( + runtimeevents.KindChannelLifecycleStopped, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityInfo, + ChannelLifecyclePayload{Type: channelTypeForEvent(m, name)}, + ) } logger.InfoC("channels", "All channels stopped") @@ -991,11 +1072,23 @@ func (m *Manager) sendWithRetry( // Rate limit: wait for token if err := w.limiter.Wait(ctx); err != nil { // ctx canceled, shutting down + m.publishChannelEvent( + runtimeevents.KindChannelRateLimited, + name, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityWarn, + ChannelOutboundPayload{ + ContentLen: len([]rune(msg.Content)), + ReplyToMessageID: msg.ReplyToMessageID, + Error: err.Error(), + }, + ) return nil, false } // Pre-send: stop typing and try to edit placeholder if msgIDs, handled := m.preSend(ctx, name, msg, w.ch); handled { + m.publishOutboundSent(name, msg, msgIDs) return msgIDs, true } @@ -1004,6 +1097,7 @@ func (m *Manager) sendWithRetry( for attempt := 0; attempt <= maxRetries; attempt++ { msgIDs, lastErr = w.ch.Send(ctx, msg) if lastErr == nil { + m.publishOutboundSent(name, msg, msgIDs) return msgIDs, true } @@ -1043,6 +1137,7 @@ func (m *Manager) sendWithRetry( "error": lastErr.Error(), "retries": maxRetries, }) + m.publishOutboundFailed(name, msg, lastErr, false) return nil, false } @@ -1105,6 +1200,7 @@ func (m *Manager) dispatchOutbound(ctx context.Context) { func(ctx context.Context, w *channelWorker, msg bus.OutboundMessage) bool { select { case w.queue <- msg: + m.publishOutboundQueued(outboundMessageChannel(msg), msg) return true case <-ctx.Done(): return false @@ -1125,6 +1221,7 @@ func (m *Manager) dispatchOutboundMedia(ctx context.Context) { func(ctx context.Context, w *channelWorker, msg bus.OutboundMediaMessage) bool { select { case w.mediaQueue <- msg: + m.publishOutboundMediaQueued(outboundMediaChannel(msg), msg) return true case <-ctx.Done(): return false @@ -1174,6 +1271,16 @@ func (m *Manager) sendMediaWithRetry( // Rate limit: wait for token if err := w.limiter.Wait(ctx); err != nil { + m.publishChannelEvent( + runtimeevents.KindChannelRateLimited, + name, + scopeFromOutboundContext(msg.Context), + runtimeevents.SeverityWarn, + ChannelOutboundPayload{ + Media: true, + Error: err.Error(), + }, + ) return nil, err } @@ -1185,6 +1292,7 @@ func (m *Manager) sendMediaWithRetry( for attempt := 0; attempt <= maxRetries; attempt++ { msgIDs, lastErr = ms.SendMedia(ctx, msg) if lastErr == nil { + m.publishOutboundMediaSent(name, msg, msgIDs) return msgIDs, nil } @@ -1224,6 +1332,7 @@ func (m *Manager) sendMediaWithRetry( "error": lastErr.Error(), "retries": maxRetries, }) + m.publishOutboundMediaFailed(name, msg, lastErr) return nil, lastErr } @@ -1361,6 +1470,13 @@ func (m *Manager) Reload(ctx context.Context, cfg *config.Config) error { "channel": name, "error": err.Error(), }) + m.publishChannelEvent( + runtimeevents.KindChannelLifecycleStartFailed, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityError, + ChannelLifecyclePayload{Type: channelTypeForEvent(m, name), Error: err.Error()}, + ) continue } // Lazily create worker only after channel starts successfully @@ -1374,6 +1490,13 @@ func (m *Manager) Reload(ctx context.Context, cfg *config.Config) error { m.workers[name] = w go m.runWorker(dispatchCtx, name, w) go m.runMediaWorker(dispatchCtx, name, w) + m.publishChannelEvent( + runtimeevents.KindChannelLifecycleStarted, + name, + runtimeevents.Scope{Channel: name}, + runtimeevents.SeverityInfo, + ChannelLifecyclePayload{Type: channelType}, + ) deferFuncs = append(deferFuncs, func() { m.RegisterChannel(name, channel) }) @@ -1496,6 +1619,7 @@ func (m *Manager) SendToChannel(ctx context.Context, channelName, chatID, conten if wExists && w != nil { select { case w.queue <- msg: + m.publishOutboundQueued(channelName, msg) return nil case <-ctx.Done(): return ctx.Err() diff --git a/pkg/channels/manager_test.go b/pkg/channels/manager_test.go index a5d7c2838..8680a08a8 100644 --- a/pkg/channels/manager_test.go +++ b/pkg/channels/manager_test.go @@ -14,6 +14,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/utils" ) @@ -242,6 +243,57 @@ func TestStartAll_PartialFailure_StartsSuccessfulWorkers(t *testing.T) { } } +func TestStartAllPublishesLifecycleRuntimeEvents(t *testing.T) { + eventBus := runtimeevents.NewBus() + defer func() { + if err := eventBus.Close(); err != nil { + t.Errorf("event bus close failed: %v", err) + } + }() + + _, eventsCh, err := eventBus.Channel().SubscribeChan( + t.Context(), + runtimeevents.SubscribeOptions{Name: "channel-lifecycle", Buffer: 4}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + m := newTestManager() + m.runtimeEvents = eventBus + m.config = &config.Config{Channels: config.ChannelsConfig{}} + m.channels["good"] = &mockChannel{} + m.channels["bad"] = &mockChannel{ + startFn: func(_ context.Context) error { return errors.New("bad start") }, + } + + if err := m.StartAll(t.Context()); err != nil { + t.Fatalf("StartAll() error = %v", err) + } + t.Cleanup(func() { + stopCtx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := m.StopAll(stopCtx); err != nil { + t.Errorf("StopAll() error = %v", err) + } + }) + + events := []runtimeevents.Event{ + receiveChannelRuntimeEvent(t, eventsCh), + receiveChannelRuntimeEvent(t, eventsCh), + } + seen := map[runtimeevents.Kind]runtimeevents.Event{} + for _, evt := range events { + seen[evt.Kind] = evt + } + if evt, ok := seen[runtimeevents.KindChannelLifecycleStarted]; !ok || evt.Scope.Channel != "good" { + t.Fatalf("missing started event for good channel: %+v", events) + } + if evt, ok := seen[runtimeevents.KindChannelLifecycleStartFailed]; !ok || evt.Scope.Channel != "bad" { + t.Fatalf("missing failed event for bad channel: %+v", events) + } +} + func testOutboundMessage(msg bus.OutboundMessage) bus.OutboundMessage { if msg.Context.Channel == "" && msg.Context.ChatID == "" { msg.Context = bus.NewOutboundContext(msg.Channel, msg.ChatID, msg.ReplyToMessageID) @@ -256,6 +308,21 @@ func testOutboundMediaMessage(msg bus.OutboundMediaMessage) bus.OutboundMediaMes return bus.NormalizeOutboundMediaMessage(msg) } +func receiveChannelRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("runtime event channel closed before expected event") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for runtime event") + return runtimeevents.Event{} + } +} + func TestSendWithRetry_Success(t *testing.T) { m := newTestManager() var callCount int @@ -280,6 +347,63 @@ func TestSendWithRetry_Success(t *testing.T) { } } +func TestSendWithRetryPublishesOutboundRuntimeEvents(t *testing.T) { + eventBus := runtimeevents.NewBus() + defer func() { + if err := eventBus.Close(); err != nil { + t.Errorf("event bus close failed: %v", err) + } + }() + + _, eventsCh, err := eventBus.Channel().OfKind( + runtimeevents.KindChannelMessageOutboundSent, + runtimeevents.KindChannelMessageOutboundFailed, + ).SubscribeChan(t.Context(), runtimeevents.SubscribeOptions{Name: "channel-outbound", Buffer: 2}) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + m := newTestManager() + m.runtimeEvents = eventBus + + successWorker := &channelWorker{ + ch: &mockChannel{}, + limiter: rate.NewLimiter(rate.Inf, 1), + } + m.sendWithRetry( + context.Background(), + "test", + successWorker, + testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "chat-1", Content: "hello"}), + ) + sent := receiveChannelRuntimeEvent(t, eventsCh) + if sent.Kind != runtimeevents.KindChannelMessageOutboundSent || sent.Scope.ChatID != "chat-1" { + t.Fatalf("sent event = %+v", sent) + } + + failWorker := &channelWorker{ + ch: &mockChannel{ + sendFn: func(context.Context, bus.OutboundMessage) error { + return fmt.Errorf("send failed: %w", ErrSendFailed) + }, + }, + limiter: rate.NewLimiter(rate.Inf, 1), + } + m.sendWithRetry( + context.Background(), + "test", + failWorker, + testOutboundMessage(bus.OutboundMessage{Channel: "test", ChatID: "chat-2", Content: "hello"}), + ) + failed := receiveChannelRuntimeEvent(t, eventsCh) + if failed.Kind != runtimeevents.KindChannelMessageOutboundFailed || failed.Scope.ChatID != "chat-2" { + t.Fatalf("failed event = %+v", failed) + } + if failed.Severity != runtimeevents.SeverityError { + t.Fatalf("failed severity = %q", failed.Severity) + } +} + func TestSendWithRetry_TemporaryThenSuccess(t *testing.T) { m := newTestManager() var callCount int diff --git a/pkg/events/kind.go b/pkg/events/kind.go index 86abfd55a..9d7319b93 100644 --- a/pkg/events/kind.go +++ b/pkg/events/kind.go @@ -47,12 +47,33 @@ const ( // KindChannelLifecycleStarted is emitted when a channel starts. KindChannelLifecycleStarted Kind = "channel.lifecycle.started" + // KindChannelLifecycleInitialized is emitted when a channel is initialized. + KindChannelLifecycleInitialized Kind = "channel.lifecycle.initialized" // KindChannelLifecycleStartFailed is emitted when a channel fails to start. KindChannelLifecycleStartFailed Kind = "channel.lifecycle.start_failed" + // KindChannelLifecycleStopped is emitted when a channel stops. + KindChannelLifecycleStopped Kind = "channel.lifecycle.stopped" + // KindChannelWebhookRegistered is emitted when a channel webhook is registered. + KindChannelWebhookRegistered Kind = "channel.webhook.registered" + // KindChannelWebhookUnregistered is emitted when a channel webhook is unregistered. + KindChannelWebhookUnregistered Kind = "channel.webhook.unregistered" + // KindChannelMessageOutboundQueued is emitted when an outbound message is queued. + KindChannelMessageOutboundQueued Kind = "channel.message.outbound_queued" // KindChannelMessageOutboundSent is emitted when an outbound channel message is sent. KindChannelMessageOutboundSent Kind = "channel.message.outbound_sent" // KindChannelMessageOutboundFailed is emitted when an outbound channel message fails. KindChannelMessageOutboundFailed Kind = "channel.message.outbound_failed" + // KindChannelRateLimited is emitted when channel rate limiting blocks delivery. + KindChannelRateLimited Kind = "channel.rate_limited" + + // KindBusPublishFailed is emitted when message bus publish fails. + KindBusPublishFailed Kind = "bus.publish.failed" + // KindBusCloseStarted is emitted when message bus close starts. + KindBusCloseStarted Kind = "bus.close.started" + // KindBusCloseCompleted is emitted when message bus close completes. + KindBusCloseCompleted Kind = "bus.close.completed" + // KindBusCloseDrained is emitted when message bus close drains buffered messages. + KindBusCloseDrained Kind = "bus.close.drained" // KindGatewayReloadStarted is emitted when gateway reload starts. KindGatewayReloadStarted Kind = "gateway.reload.started" @@ -63,6 +84,14 @@ const ( // KindMCPServerConnected is emitted when an MCP server connects. KindMCPServerConnected Kind = "mcp.server.connected" + // KindMCPServerConnecting is emitted before connecting to an MCP server. + KindMCPServerConnecting Kind = "mcp.server.connecting" // KindMCPServerFailed is emitted when an MCP server fails. KindMCPServerFailed Kind = "mcp.server.failed" + // KindMCPToolDiscovered is emitted when an MCP tool is discovered. + KindMCPToolDiscovered Kind = "mcp.tool.discovered" + // KindMCPToolCallStart is emitted when an MCP tool call starts. + KindMCPToolCallStart Kind = "mcp.tool.call.start" + // KindMCPToolCallEnd is emitted when an MCP tool call ends. + KindMCPToolCallEnd Kind = "mcp.tool.call.end" ) diff --git a/pkg/gateway/events.go b/pkg/gateway/events.go new file mode 100644 index 000000000..d690a4eaf --- /dev/null +++ b/pkg/gateway/events.go @@ -0,0 +1,46 @@ +package gateway + +import ( + "context" + "time" + + "github.com/sipeed/picoclaw/pkg/agent" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +const gatewayEventPublishTimeout = 100 * time.Millisecond + +type gatewayReloadPayload struct { + DurationMS int64 `json:"duration_ms,omitempty"` + Error string `json:"error,omitempty"` +} + +func publishGatewayReloadEvent( + al *agent.AgentLoop, + kind runtimeevents.Kind, + startedAt time.Time, + err error, +) { + if al == nil || al.RuntimeEventBus() == nil { + return + } + + severity := runtimeevents.SeverityInfo + payload := gatewayReloadPayload{} + if !startedAt.IsZero() { + payload.DurationMS = time.Since(startedAt).Milliseconds() + } + if err != nil { + severity = runtimeevents.SeverityError + payload.Error = err.Error() + } + + ctx, cancel := context.WithTimeout(context.Background(), gatewayEventPublishTimeout) + defer cancel() + al.RuntimeEventBus().Publish(ctx, runtimeevents.Event{ + Kind: kind, + Source: runtimeevents.Source{Component: "gateway"}, + Severity: severity, + Payload: payload, + }) +} diff --git a/pkg/gateway/gateway.go b/pkg/gateway/gateway.go index f58590d5b..01b6f7d5e 100644 --- a/pkg/gateway/gateway.go +++ b/pkg/gateway/gateway.go @@ -39,6 +39,7 @@ import ( "github.com/sipeed/picoclaw/pkg/config" "github.com/sipeed/picoclaw/pkg/cron" "github.com/sipeed/picoclaw/pkg/devices" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/health" "github.com/sipeed/picoclaw/pkg/heartbeat" "github.com/sipeed/picoclaw/pkg/logger" @@ -197,6 +198,7 @@ func Run(debug bool, homePath, configPath string, allowEmptyStartup bool) (runEr msgBus := bus.NewMessageBus() agentLoop := agent.NewAgentLoop(cfg, msgBus, provider) + msgBus.SetEventPublisher(agentLoop.RuntimeEventBus()) fmt.Println("\n📦 Agent Status:") startupInfo := agentLoop.GetStartupInfo() @@ -312,10 +314,20 @@ func executeReload( msgBus *bus.MessageBus, allowEmptyStartup bool, debug bool, -) error { +) (err error) { + startedAt := time.Now() + publishGatewayReloadEvent(agentLoop, runtimeevents.KindGatewayReloadStarted, startedAt, nil) defer runningServices.reloading.Store(false) + defer func() { + if err != nil { + publishGatewayReloadEvent(agentLoop, runtimeevents.KindGatewayReloadFailed, startedAt, err) + return + } + publishGatewayReloadEvent(agentLoop, runtimeevents.KindGatewayReloadCompleted, startedAt, nil) + }() - return handleConfigReload(ctx, agentLoop, newCfg, provider, runningServices, msgBus, allowEmptyStartup, debug) + err = handleConfigReload(ctx, agentLoop, newCfg, provider, runningServices, msgBus, allowEmptyStartup, debug) + return err } func createStartupProvider( @@ -383,7 +395,12 @@ func setupAndStartServices( fms.Start() } - runningServices.ChannelManager, err = channels.NewManager(cfg, msgBus, runningServices.MediaStore) + runningServices.ChannelManager, err = channels.NewManager( + cfg, + msgBus, + runningServices.MediaStore, + channels.WithRuntimeEvents(agentLoop.RuntimeEventBus()), + ) if err != nil { if fms, ok := runningServices.MediaStore.(*media.FileMediaStore); ok { fms.Stop() diff --git a/pkg/mcp/events.go b/pkg/mcp/events.go new file mode 100644 index 000000000..843fa9088 --- /dev/null +++ b/pkg/mcp/events.go @@ -0,0 +1,81 @@ +package mcp + +import ( + "context" + "time" + + "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +const mcpEventPublishTimeout = 100 * time.Millisecond + +func (m *Manager) publishServerEvent( + kind runtimeevents.Kind, + serverName string, + cfg config.MCPServerConfig, + toolCount int, + err error, +) { + if m == nil || m.runtimeEvents == nil { + return + } + + severity := runtimeevents.SeverityInfo + if err != nil { + severity = runtimeevents.SeverityError + } + payload := ServerEventPayload{ + Server: serverName, + Type: mcpTransportType(cfg), + URL: cfg.URL, + Command: cfg.Command, + ToolCount: toolCount, + } + if err != nil { + payload.Error = err.Error() + } + + ctx, cancel := context.WithTimeout(context.Background(), mcpEventPublishTimeout) + defer cancel() + m.runtimeEvents.Publish(ctx, runtimeevents.Event{ + Kind: kind, + Source: runtimeevents.Source{Component: "mcp", Name: serverName}, + Severity: severity, + Payload: payload, + }) +} + +func (m *Manager) publishToolDiscovered(serverName string, cfg config.MCPServerConfig, toolName string) { + if m == nil || m.runtimeEvents == nil { + return + } + payload := ServerEventPayload{ + Server: serverName, + Type: mcpTransportType(cfg), + URL: cfg.URL, + Command: cfg.Command, + Tool: toolName, + } + ctx, cancel := context.WithTimeout(context.Background(), mcpEventPublishTimeout) + defer cancel() + m.runtimeEvents.Publish(ctx, runtimeevents.Event{ + Kind: runtimeevents.KindMCPToolDiscovered, + Source: runtimeevents.Source{Component: "mcp", Name: serverName}, + Severity: runtimeevents.SeverityInfo, + Payload: payload, + }) +} + +func mcpTransportType(cfg config.MCPServerConfig) string { + if cfg.Type != "" { + return cfg.Type + } + if cfg.URL != "" { + return "sse" + } + if cfg.Command != "" { + return "stdio" + } + return "" +} diff --git a/pkg/mcp/manager.go b/pkg/mcp/manager.go index 92ea426a6..958927767 100644 --- a/pkg/mcp/manager.go +++ b/pkg/mcp/manager.go @@ -16,6 +16,7 @@ import ( "github.com/modelcontextprotocol/go-sdk/mcp" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" ) @@ -127,19 +128,47 @@ type ServerConnection struct { // Manager manages multiple MCP server connections type Manager struct { - servers map[string]*ServerConnection - mu sync.RWMutex - closed atomic.Bool // changed from bool to atomic.Bool to avoid TOCTOU race - wg sync.WaitGroup // tracks in-flight CallTool calls + servers map[string]*ServerConnection + runtimeEvents runtimeevents.Bus + mu sync.RWMutex + closed atomic.Bool // changed from bool to atomic.Bool to avoid TOCTOU race + wg sync.WaitGroup // tracks in-flight CallTool calls } var connectServerFunc = connectServer +// ManagerOption configures an MCP manager. +type ManagerOption func(*Manager) + +// WithRuntimeEvents injects the runtime event bus used for MCP observations. +func WithRuntimeEvents(eventBus runtimeevents.Bus) ManagerOption { + return func(m *Manager) { + m.runtimeEvents = eventBus + } +} + +// ServerEventPayload describes MCP server connection events. +type ServerEventPayload struct { + Server string `json:"server"` + Type string `json:"type,omitempty"` + URL string `json:"url,omitempty"` + Command string `json:"command,omitempty"` + Tool string `json:"tool,omitempty"` + ToolCount int `json:"tool_count,omitempty"` + Error string `json:"error,omitempty"` +} + // NewManager creates a new MCP manager -func NewManager() *Manager { - return &Manager{ +func NewManager(opts ...ManagerOption) *Manager { + m := &Manager{ servers: make(map[string]*ServerConnection), } + for _, opt := range opts { + if opt != nil { + opt(m) + } + } + return m } // LoadFromConfig loads MCP servers from configuration @@ -264,8 +293,10 @@ func (m *Manager) ConnectServer( name string, cfg config.MCPServerConfig, ) error { + m.publishServerEvent(runtimeevents.KindMCPServerConnecting, name, cfg, 0, nil) conn, err := connectServerFunc(ctx, name, cfg) if err != nil { + m.publishServerEvent(runtimeevents.KindMCPServerFailed, name, cfg, 0, err) return err } @@ -274,10 +305,19 @@ func (m *Manager) ConnectServer( if m.closed.Load() { _ = conn.Session.Close() + m.publishServerEvent(runtimeevents.KindMCPServerFailed, name, cfg, 0, fmt.Errorf("manager is closed")) return fmt.Errorf("manager is closed") } m.servers[name] = conn + for _, tool := range conn.Tools { + toolName := "" + if tool != nil { + toolName = tool.Name + } + m.publishToolDiscovered(name, cfg, toolName) + } + m.publishServerEvent(runtimeevents.KindMCPServerConnected, name, cfg, len(conn.Tools), nil) return nil } diff --git a/pkg/mcp/manager_test.go b/pkg/mcp/manager_test.go index 682d4c346..17b272820 100644 --- a/pkg/mcp/manager_test.go +++ b/pkg/mcp/manager_test.go @@ -10,11 +10,13 @@ import ( "strings" "sync" "testing" + "time" "github.com/modelcontextprotocol/go-sdk/jsonrpc" sdkmcp "github.com/modelcontextprotocol/go-sdk/mcp" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) func TestLoadEnvFile(t *testing.T) { @@ -248,6 +250,87 @@ func TestNewManager_InitialState(t *testing.T) { } } +func TestConnectServerPublishesRuntimeEvents(t *testing.T) { + originalConnectServerFunc := connectServerFunc + t.Cleanup(func() { + connectServerFunc = originalConnectServerFunc + }) + + eventBus := runtimeevents.NewBus() + defer func() { + if err := eventBus.Close(); err != nil { + t.Errorf("event bus close failed: %v", err) + } + }() + + _, eventsCh, err := eventBus.Channel().OfKind( + runtimeevents.KindMCPServerConnected, + runtimeevents.KindMCPServerFailed, + ).SubscribeChan(t.Context(), runtimeevents.SubscribeOptions{Name: "mcp-events", Buffer: 2}) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + connectServerFunc = func( + _ context.Context, + name string, + cfg config.MCPServerConfig, + ) (*ServerConnection, error) { + if name == "bad" { + return nil, fmt.Errorf("connect failed") + } + return &ServerConnection{ + Name: name, + Config: cfg, + Tools: []*sdkmcp.Tool{{Name: "echo"}}, + }, nil + } + + mgr := NewManager(WithRuntimeEvents(eventBus)) + err = mgr.ConnectServer(context.Background(), "good", config.MCPServerConfig{ + Type: "stdio", + Command: "echo", + }) + if err != nil { + t.Fatalf("ConnectServer(good) error = %v", err) + } + connected := receiveMCPRuntimeEvent(t, eventsCh) + if connected.Kind != runtimeevents.KindMCPServerConnected || + connected.Source.Name != "good" || + connected.Severity != runtimeevents.SeverityInfo { + t.Fatalf("connected event = %+v", connected) + } + + err = mgr.ConnectServer(context.Background(), "bad", config.MCPServerConfig{ + Type: "stdio", + Command: "echo", + }) + if err == nil { + t.Fatal("expected ConnectServer(bad) to fail") + } + failed := receiveMCPRuntimeEvent(t, eventsCh) + if failed.Kind != runtimeevents.KindMCPServerFailed || + failed.Source.Name != "bad" || + failed.Severity != runtimeevents.SeverityError { + t.Fatalf("failed event = %+v", failed) + } +} + +func receiveMCPRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("runtime event channel closed before expected event") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for runtime event") + return runtimeevents.Event{} + } +} + func TestLoadFromMCPConfig_DisabledOrEmptyServers(t *testing.T) { mgr := NewManager() diff --git a/pkg/tools/integration/mcp_tool.go b/pkg/tools/integration/mcp_tool.go index 78c348316..1ee86a4a9 100644 --- a/pkg/tools/integration/mcp_tool.go +++ b/pkg/tools/integration/mcp_tool.go @@ -13,6 +13,7 @@ import ( "github.com/modelcontextprotocol/go-sdk/mcp" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/media" toolshared "github.com/sipeed/picoclaw/pkg/tools/shared" @@ -36,6 +37,16 @@ type MCPTool struct { mediaStore media.MediaStore workspace string maxInlineTextRunes int + runtimeEvents runtimeevents.Bus +} + +// MCPToolCallPayload describes MCP tool execution runtime events. +type MCPToolCallPayload struct { + Server string `json:"server"` + Tool string `json:"tool"` + DurationMS int64 `json:"duration_ms,omitempty"` + IsError bool `json:"is_error,omitempty"` + Error string `json:"error,omitempty"` } // NewMCPTool creates a new MCP tool wrapper @@ -62,6 +73,11 @@ func (t *MCPTool) SetMaxInlineTextRunes(limit int) { } } +// SetEventPublisher injects the runtime event bus used for MCP tool observations. +func (t *MCPTool) SetEventPublisher(eventBus runtimeevents.Bus) { + t.runtimeEvents = eventBus +} + const maxMCPInlineTextRunes = 16 * 1024 // sanitizeIdentifierComponent normalizes a string so it can be safely used @@ -237,26 +253,74 @@ func (t *MCPTool) Parameters() map[string]any { // Execute executes the MCP tool func (t *MCPTool) Execute(ctx context.Context, args map[string]any) *ToolResult { + startedAt := time.Now() + t.publishRuntimeEvent(ctx, runtimeevents.KindMCPToolCallStart, startedAt, false, "") + result, err := t.manager.CallTool(ctx, t.serverName, t.tool.Name, args) if err != nil { + t.publishRuntimeEvent(ctx, runtimeevents.KindMCPToolCallEnd, startedAt, true, err.Error()) return ErrorResult(fmt.Sprintf("MCP tool execution failed: %v", err)).WithError(err) } if result == nil { nilErr := fmt.Errorf("MCP tool returned nil result without error") + t.publishRuntimeEvent(ctx, runtimeevents.KindMCPToolCallEnd, startedAt, true, nilErr.Error()) return ErrorResult("MCP tool execution failed: nil result").WithError(nilErr) } // Handle error result from server if result.IsError { errMsg := extractContentText(result.Content) + t.publishRuntimeEvent(ctx, runtimeevents.KindMCPToolCallEnd, startedAt, true, errMsg) return ErrorResult(fmt.Sprintf("MCP tool returned error: %s", errMsg)). WithError(fmt.Errorf("MCP tool error: %s", errMsg)) } + t.publishRuntimeEvent(ctx, runtimeevents.KindMCPToolCallEnd, startedAt, false, "") return t.normalizeResultContent(ctx, result.Content) } +func (t *MCPTool) publishRuntimeEvent( + ctx context.Context, + kind runtimeevents.Kind, + startedAt time.Time, + isError bool, + errMsg string, +) { + if t == nil || t.runtimeEvents == nil { + return + } + + scope := runtimeevents.Scope{ + AgentID: toolshared.ToolAgentID(ctx), + SessionKey: toolshared.ToolSessionKey(ctx), + Channel: toolshared.ToolChannel(ctx), + ChatID: toolshared.ToolChatID(ctx), + MessageID: toolshared.ToolMessageID(ctx), + } + payload := MCPToolCallPayload{ + Server: t.serverName, + Tool: t.tool.Name, + DurationMS: time.Since(startedAt).Milliseconds(), + IsError: isError, + Error: errMsg, + } + severity := runtimeevents.SeverityInfo + if isError { + severity = runtimeevents.SeverityError + } + + publishCtx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) + defer cancel() + t.runtimeEvents.Publish(publishCtx, runtimeevents.Event{ + Kind: kind, + Source: runtimeevents.Source{Component: "mcp", Name: t.serverName}, + Scope: scope, + Severity: severity, + Payload: payload, + }) +} + // extractContentText extracts text from MCP content array func extractContentText(content []mcp.Content) string { var parts []string diff --git a/pkg/tools/integration/mcp_tool_test.go b/pkg/tools/integration/mcp_tool_test.go index 7b0b2cd5a..f346e5329 100644 --- a/pkg/tools/integration/mcp_tool_test.go +++ b/pkg/tools/integration/mcp_tool_test.go @@ -7,9 +7,11 @@ import ( "path/filepath" "strings" "testing" + "time" "github.com/modelcontextprotocol/go-sdk/mcp" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/media" toolshared "github.com/sipeed/picoclaw/pkg/tools/shared" ) @@ -299,6 +301,72 @@ func TestMCPTool_Execute_Success(t *testing.T) { } } +func TestMCPTool_Execute_PublishesRuntimeEvents(t *testing.T) { + eventBus := runtimeevents.NewBus() + defer func() { + if err := eventBus.Close(); err != nil { + t.Errorf("event bus close failed: %v", err) + } + }() + + _, eventsCh, err := eventBus.Channel().OfKind( + runtimeevents.KindMCPToolCallStart, + runtimeevents.KindMCPToolCallEnd, + ).SubscribeChan(t.Context(), runtimeevents.SubscribeOptions{Name: "mcp-tool-events", Buffer: 2}) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + manager := &MockMCPManager{} + mcpTool := NewMCPTool(manager, "github", &mcp.Tool{Name: "search_repos"}) + mcpTool.SetEventPublisher(eventBus) + + ctx := toolshared.WithToolContext(context.Background(), "telegram", "chat-1") + ctx = toolshared.WithToolMessageContext(ctx, "msg-1", "") + ctx = toolshared.WithToolSessionContext(ctx, "main", "session-1", nil) + result := mcpTool.Execute(ctx, map[string]any{"query": "picoclaw"}) + if result == nil || result.IsError { + t.Fatalf("Execute result = %+v", result) + } + + started := receiveMCPToolRuntimeEvent(t, eventsCh) + if started.Kind != runtimeevents.KindMCPToolCallStart || + started.Scope.AgentID != "main" || + started.Scope.SessionKey != "session-1" || + started.Scope.Channel != "telegram" || + started.Scope.ChatID != "chat-1" || + started.Scope.MessageID != "msg-1" { + t.Fatalf("started event = %+v", started) + } + + ended := receiveMCPToolRuntimeEvent(t, eventsCh) + if ended.Kind != runtimeevents.KindMCPToolCallEnd || ended.Severity != runtimeevents.SeverityInfo { + t.Fatalf("ended event = %+v", ended) + } + payload, ok := ended.Payload.(MCPToolCallPayload) + if !ok { + t.Fatalf("ended payload = %T, want MCPToolCallPayload", ended.Payload) + } + if payload.Server != "github" || payload.Tool != "search_repos" || payload.IsError { + t.Fatalf("ended payload = %+v", payload) + } +} + +func receiveMCPToolRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { + t.Helper() + + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("runtime event channel closed before expected event") + } + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for runtime event") + return runtimeevents.Event{} + } +} + // TestMCPTool_Execute_ManagerError tests execution when manager returns error func TestMCPTool_Execute_ManagerError(t *testing.T) { manager := &MockMCPManager{ From d9717b5632a8858f0c69919fbf4b304296d4adfa Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:11:09 +0800 Subject: [PATCH 15/53] refactor(events): start runtime event consumer migration Deprecate the legacy agent event APIs and add a runtime event test helper, then migrate the follow-up queued test to the runtime event stream. Validation: go test ./pkg/agent; make lint --- pkg/agent/agent_event.go | 6 +++ pkg/agent/eventbus.go | 7 ++++ pkg/agent/eventbus_test.go | 19 ++++++---- pkg/agent/events.go | 7 ++++ pkg/agent/hooks.go | 1 + pkg/agent/runtime_event_test.go | 66 +++++++++++++++++++++++++++++++++ 6 files changed, 99 insertions(+), 7 deletions(-) create mode 100644 pkg/agent/runtime_event_test.go diff --git a/pkg/agent/agent_event.go b/pkg/agent/agent_event.go index 5ba6c579c..6bbd275e5 100644 --- a/pkg/agent/agent_event.go +++ b/pkg/agent/agent_event.go @@ -166,6 +166,8 @@ func (al *AgentLoop) UnmountHook(name string) { } // SubscribeEvents registers a subscriber for agent-loop events. +// +// Deprecated: use RuntimeEvents for new event observation code. func (al *AgentLoop) SubscribeEvents(buffer int) EventSubscription { if al == nil || al.eventBus == nil { ch := make(chan Event) @@ -176,6 +178,8 @@ func (al *AgentLoop) SubscribeEvents(buffer int) EventSubscription { } // UnsubscribeEvents removes a previously registered event subscriber. +// +// Deprecated: use the Subscription returned by RuntimeEvents instead. func (al *AgentLoop) UnsubscribeEvents(id uint64) { if al == nil || al.eventBus == nil { return @@ -184,6 +188,8 @@ func (al *AgentLoop) UnsubscribeEvents(id uint64) { } // EventDrops returns the number of dropped events for the given kind. +// +// Deprecated: use RuntimeEventStats for runtime event drop counters. func (al *AgentLoop) EventDrops(kind EventKind) int64 { if al == nil || al.eventBus == nil { return 0 diff --git a/pkg/agent/eventbus.go b/pkg/agent/eventbus.go index 546d8436d..54ada62fb 100644 --- a/pkg/agent/eventbus.go +++ b/pkg/agent/eventbus.go @@ -9,6 +9,8 @@ import ( const defaultEventSubscriberBuffer = 16 // EventSubscription identifies a subscriber channel returned by EventBus.Subscribe. +// +// Deprecated: use pkg/events.Subscription from RuntimeEvents for new code. type EventSubscription struct { ID uint64 C <-chan Event @@ -19,6 +21,9 @@ type eventSubscriber struct { } // EventBus is a lightweight multi-subscriber broadcaster for agent-loop events. +// +// Deprecated: use pkg/events.EventBus for new code. This legacy bus remains +// only while existing agent event consumers migrate. type EventBus struct { mu sync.RWMutex subs map[uint64]eventSubscriber @@ -28,6 +33,8 @@ type EventBus struct { } // NewEventBus creates a new in-process event broadcaster. +// +// Deprecated: use events.NewBus for new runtime event publishers. func NewEventBus() *EventBus { return &EventBus{ subs: make(map[uint64]eventSubscriber), diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 4a5de46c9..614f12f9d 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -670,8 +670,13 @@ func TestAgentLoop_EmitsFollowUpQueuedEvent(t *testing.T) { t.Fatal("expected default agent") } - sub := al.SubscribeEvents(32) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 32, + runtimeevents.KindAgentFollowUpQueued, + ) + defer closeRuntimeEvents() resp, err := al.runAgentLoop(context.Background(), defaultAgent, processOptions{ SessionKey: "session-1", @@ -695,8 +700,8 @@ func TestAgentLoop_EmitsFollowUpQueuedEvent(t *testing.T) { t.Fatal("timeout waiting for async tool completion") } - followUpEvt := waitForEvent(t, sub.C, 2*time.Second, func(evt Event) bool { - return evt.Kind == EventKindFollowUpQueued + followUpEvt := waitForRuntimeEvent(t, runtimeCh, 2*time.Second, func(evt runtimeevents.Event) bool { + return evt.Kind == runtimeevents.KindAgentFollowUpQueued }) payload, ok := followUpEvt.Payload.(FollowUpQueuedPayload) if !ok { @@ -708,10 +713,10 @@ func TestAgentLoop_EmitsFollowUpQueuedEvent(t *testing.T) { if payload.ContentLen != len("background result") { t.Fatalf("expected content len %d, got %d", len("background result"), payload.ContentLen) } - if followUpEvt.Meta.SessionKey != "session-1" { - t.Fatalf("expected session key session-1, got %q", followUpEvt.Meta.SessionKey) + if followUpEvt.Scope.SessionKey != "session-1" { + t.Fatalf("expected session key session-1, got %q", followUpEvt.Scope.SessionKey) } - if followUpEvt.Meta.TurnID == "" { + if followUpEvt.Scope.TurnID == "" { t.Fatal("expected follow-up event to include turn id") } } diff --git a/pkg/agent/events.go b/pkg/agent/events.go index f68d3eab5..a2d466b9e 100644 --- a/pkg/agent/events.go +++ b/pkg/agent/events.go @@ -6,6 +6,10 @@ import ( ) // EventKind identifies a structured agent-loop event. +// +// Deprecated: use github.com/sipeed/picoclaw/pkg/events.Kind for new runtime +// event consumers. This legacy kind exists only during the runtime event +// migration window. type EventKind uint8 const ( @@ -82,6 +86,9 @@ func (k EventKind) String() string { } // Event is the structured envelope broadcast by the agent EventBus. +// +// Deprecated: use github.com/sipeed/picoclaw/pkg/events.Event for new +// observation code. Agent payload types remain supported. type Event struct { Kind EventKind Time time.Time diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index b84362fc1..0a6c6785a 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -73,6 +73,7 @@ func NamedHook(name string, hook any) HookRegistration { } type EventObserver interface { + // Deprecated: implement RuntimeEventObserver for new observation code. OnEvent(ctx context.Context, evt Event) error } diff --git a/pkg/agent/runtime_event_test.go b/pkg/agent/runtime_event_test.go new file mode 100644 index 000000000..47fd6923a --- /dev/null +++ b/pkg/agent/runtime_event_test.go @@ -0,0 +1,66 @@ +package agent + +import ( + "testing" + "time" + + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +func subscribeRuntimeEventsForTest( + t *testing.T, + al *AgentLoop, + buffer int, + kinds ...runtimeevents.Kind, +) (<-chan runtimeevents.Event, func()) { + t.Helper() + + if al == nil { + t.Fatal("agent loop is nil") + } + channel := al.RuntimeEvents() + if channel == nil { + t.Fatal("runtime event channel is nil") + } + if len(kinds) > 0 { + channel = channel.OfKind(kinds...) + } + sub, ch, err := channel.SubscribeChan( + t.Context(), + runtimeevents.SubscribeOptions{Name: "agent-runtime-test", Buffer: buffer}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + return ch, func() { + if err := sub.Close(); err != nil { + t.Errorf("runtime subscription close failed: %v", err) + } + } +} + +func waitForRuntimeEvent( + t *testing.T, + ch <-chan runtimeevents.Event, + timeout time.Duration, + match func(runtimeevents.Event) bool, +) runtimeevents.Event { + t.Helper() + + timer := time.NewTimer(timeout) + defer timer.Stop() + + for { + select { + case evt, ok := <-ch: + if !ok { + t.Fatal("runtime event stream closed before expected event arrived") + } + if match(evt) { + return evt + } + case <-timer.C: + t.Fatal("timed out waiting for expected runtime event") + } + } +} From dc80e8f5f20662a9f8d0587b6f89bf04bf87b541 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:23:58 +0800 Subject: [PATCH 16/53] test(events): migrate agent tests to runtime events Move AgentLoop event assertions to the runtime event stream and keep the legacy SubscribeEvents test only for dual-publish compatibility. Validation: go test ./pkg/agent; make lint --- pkg/agent/agent_test.go | 15 ++- pkg/agent/context_manager_test.go | 43 ++++++--- pkg/agent/eventbus_test.go | 148 ++++++++++++------------------ pkg/agent/hook_process_test.go | 14 ++- pkg/agent/hooks_test.go | 95 +++++++++++-------- pkg/agent/runtime_event_test.go | 37 ++++++++ pkg/agent/steering_test.go | 33 +++++-- pkg/agent/subturn_test.go | 75 ++++++++++----- 8 files changed, 277 insertions(+), 183 deletions(-) diff --git a/pkg/agent/agent_test.go b/pkg/agent/agent_test.go index 01657d43a..13c5b21a0 100644 --- a/pkg/agent/agent_test.go +++ b/pkg/agent/agent_test.go @@ -19,6 +19,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/channels" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/media" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" @@ -5217,13 +5218,19 @@ func TestParallelMessageProcessing_SameSessionProcessedSequentially(t *testing.T }) defer al.Close() - sub := al.SubscribeEvents(64) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 64, + runtimeevents.KindAgentTurnStart, + ) + defer closeRuntimeEvents() go func() { - for evt := range sub.C { - if evt.Kind == EventKindTurnStart { + for evt := range runtimeCh { + if evt.Kind == runtimeevents.KindAgentTurnStart { mu.Lock() - turnIDs[evt.Meta.TurnID] = true + turnIDs[evt.Scope.TurnID] = true mu.Unlock() } } diff --git a/pkg/agent/context_manager_test.go b/pkg/agent/context_manager_test.go index 629d11fcb..46e521be4 100644 --- a/pkg/agent/context_manager_test.go +++ b/pkg/agent/context_manager_test.go @@ -12,6 +12,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/providers" ) @@ -305,8 +306,13 @@ func TestLegacyCompact_Overflow(t *testing.T) { } defaultAgent.Sessions.SetHistory("session-overflow", history) - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentContextCompress, + ) + defer closeRuntimeEvents() err := al.contextManager.Compact(context.Background(), &CompactRequest{ SessionKey: "session-overflow", @@ -329,8 +335,8 @@ func TestLegacyCompact_Overflow(t *testing.T) { } // Event should carry the proactive reason - events := collectEventStream(sub.C) - compressEvt, ok := findEvent(events, EventKindContextCompress) + events := collectRuntimeEventStream(runtimeCh) + compressEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentContextCompress) if !ok { t.Fatal("expected context compress event") } @@ -361,8 +367,13 @@ func TestLegacyCompact_Overflow_ProactiveReason(t *testing.T) { } defaultAgent.Sessions.SetHistory("session-proactive", history) - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentContextCompress, + ) + defer closeRuntimeEvents() err := al.contextManager.Compact(context.Background(), &CompactRequest{ SessionKey: "session-proactive", @@ -372,8 +383,8 @@ func TestLegacyCompact_Overflow_ProactiveReason(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - events := collectEventStream(sub.C) - compressEvt, ok := findEvent(events, EventKindContextCompress) + events := collectRuntimeEventStream(runtimeCh) + compressEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentContextCompress) if !ok { t.Fatal("expected context compress event") } @@ -483,6 +494,14 @@ func TestLegacyCompact_PostTurn_ExceedsMessageThreshold(t *testing.T) { } defaultAgent.Sessions.SetHistory("session-threshold", history) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentSessionSummarize, + ) + defer closeRuntimeEvents() + err := al.contextManager.Compact(context.Background(), &CompactRequest{ SessionKey: "session-threshold", Reason: ContextCompressReasonSummarize, @@ -491,12 +510,8 @@ func TestLegacyCompact_PostTurn_ExceedsMessageThreshold(t *testing.T) { t.Fatalf("unexpected error: %v", err) } - // Wait for async summarization to complete via event - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) - - waitForEvent(t, sub.C, 5*time.Second, func(evt Event) bool { - return evt.Kind == EventKindSessionSummarize + waitForRuntimeEvent(t, runtimeCh, 5*time.Second, func(evt runtimeevents.Event) bool { + return evt.Kind == runtimeevents.KindAgentSessionSummarize }) newHistory := defaultAgent.Sessions.GetHistory("session-threshold") diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 614f12f9d..87b1c68b1 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -222,8 +222,18 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { t.Fatal("expected default agent") } - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + expectedKinds := []runtimeevents.Kind{ + runtimeevents.KindAgentTurnStart, + runtimeevents.KindAgentLLMRequest, + runtimeevents.KindAgentLLMResponse, + runtimeevents.KindAgentToolExecStart, + runtimeevents.KindAgentToolExecEnd, + runtimeevents.KindAgentLLMRequest, + runtimeevents.KindAgentLLMResponse, + runtimeevents.KindAgentTurnEnd, + } + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest(t, al, 16, expectedKinds...) + defer closeRuntimeEvents() response, err := al.runAgentLoop(context.Background(), defaultAgent, processOptions{ SessionKey: "session-1", @@ -266,49 +276,36 @@ func TestAgentLoop_EmitsMinimalTurnEvents(t *testing.T) { t.Fatalf("expected final response 'done', got %q", response) } - events := collectEventStream(sub.C) + events := collectRuntimeEventStream(runtimeCh) if len(events) != 8 { t.Fatalf("expected 8 events, got %d", len(events)) } - kinds := make([]EventKind, 0, len(events)) + kinds := make([]runtimeevents.Kind, 0, len(events)) for _, evt := range events { kinds = append(kinds, evt.Kind) } - expectedKinds := []EventKind{ - EventKindTurnStart, - EventKindLLMRequest, - EventKindLLMResponse, - EventKindToolExecStart, - EventKindToolExecEnd, - EventKindLLMRequest, - EventKindLLMResponse, - EventKindTurnEnd, - } if !slices.Equal(kinds, expectedKinds) { t.Fatalf("unexpected event sequence: got %v want %v", kinds, expectedKinds) } - turnID := events[0].Meta.TurnID + turnID := events[0].Scope.TurnID + if turnID == "" { + t.Fatal("expected runtime events to include turn id") + } for i, evt := range events { - if evt.Meta.TurnID != turnID { - t.Fatalf("event %d has mismatched turn id %q, want %q", i, evt.Meta.TurnID, turnID) + if evt.Scope.TurnID != turnID { + t.Fatalf("event %d has mismatched turn id %q, want %q", i, evt.Scope.TurnID, turnID) } - if evt.Meta.SessionKey != "session-1" { - t.Fatalf("event %d has session key %q, want session-1", i, evt.Meta.SessionKey) + if evt.Scope.SessionKey != "session-1" { + t.Fatalf("event %d has session key %q, want session-1", i, evt.Scope.SessionKey) } - if evt.Context == nil || evt.Context.Inbound == nil { - t.Fatalf("event %d missing inbound turn context", i) + if evt.Scope.Channel != "cli" || evt.Scope.ChatID != "direct" || evt.Scope.SenderID != "tester" { + t.Fatalf("event %d scope = %+v", i, evt.Scope) } - if evt.Context.Inbound.Channel != "cli" || evt.Context.Inbound.SenderID != "tester" { - t.Fatalf("event %d inbound context = %+v", i, evt.Context.Inbound) - } - if evt.Context.Route == nil || evt.Context.Route.AgentID != "main" { - t.Fatalf("event %d missing route context: %+v", i, evt.Context.Route) - } - if evt.Context.Scope == nil || evt.Context.Scope.Values["sender"] != "tester" { - t.Fatalf("event %d missing session scope: %+v", i, evt.Context.Scope) + if evt.Scope.AgentID != "main" { + t.Fatalf("event %d has agent id %q, want main", i, evt.Scope.AgentID) } } @@ -404,8 +401,15 @@ func TestAgentLoop_EmitsSteeringAndSkippedToolEvents(t *testing.T) { al.RegisterTool(tool1) al.RegisterTool(tool2) - sub := al.SubscribeEvents(32) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 32, + runtimeevents.KindAgentSteeringInjected, + runtimeevents.KindAgentToolExecSkipped, + runtimeevents.KindAgentInterruptReceived, + ) + defer closeRuntimeEvents() resultCh := make(chan string, 1) go func() { @@ -432,8 +436,8 @@ func TestAgentLoop_EmitsSteeringAndSkippedToolEvents(t *testing.T) { t.Fatal("timeout waiting for steered response") } - events := collectEventStream(sub.C) - steeringEvt, ok := findEvent(events, EventKindSteeringInjected) + events := collectRuntimeEventStream(runtimeCh) + steeringEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentSteeringInjected) if !ok { t.Fatal("expected steering injected event") } @@ -445,7 +449,7 @@ func TestAgentLoop_EmitsSteeringAndSkippedToolEvents(t *testing.T) { t.Fatalf("expected 1 steering message, got %d", steeringPayload.Count) } - skippedEvt, ok := findEvent(events, EventKindToolExecSkipped) + skippedEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentToolExecSkipped) if !ok { t.Fatal("expected skipped tool event") } @@ -457,7 +461,7 @@ func TestAgentLoop_EmitsSteeringAndSkippedToolEvents(t *testing.T) { t.Fatalf("expected skipped tool_two, got %q", skippedPayload.Tool) } - interruptEvt, ok := findEvent(events, EventKindInterruptReceived) + interruptEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentInterruptReceived) if !ok { t.Fatal("expected interrupt received event") } @@ -515,8 +519,14 @@ func TestAgentLoop_EmitsContextCompressEventOnRetry(t *testing.T) { {Role: "user", Content: "Trigger message"}, }) - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentLLMRetry, + runtimeevents.KindAgentContextCompress, + ) + defer closeRuntimeEvents() resp, err := al.runAgentLoop(context.Background(), defaultAgent, processOptions{ SessionKey: "session-1", @@ -534,8 +544,8 @@ func TestAgentLoop_EmitsContextCompressEventOnRetry(t *testing.T) { t.Fatalf("expected retry success, got %q", resp) } - events := collectEventStream(sub.C) - retryEvt, ok := findEvent(events, EventKindLLMRetry) + events := collectRuntimeEventStream(runtimeCh) + retryEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentLLMRetry) if !ok { t.Fatal("expected llm retry event") } @@ -550,7 +560,7 @@ func TestAgentLoop_EmitsContextCompressEventOnRetry(t *testing.T) { t.Fatalf("expected retry attempt 1, got %d", retryPayload.Attempt) } - compressEvt, ok := findEvent(events, EventKindContextCompress) + compressEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentContextCompress) if !ok { t.Fatal("expected context compress event") } @@ -603,14 +613,19 @@ func TestAgentLoop_EmitsSessionSummarizeEvent(t *testing.T) { {Role: "assistant", Content: "Answer three"}, }) - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentSessionSummarize, + ) + defer closeRuntimeEvents() lcm := &legacyContextManager{al: al} lcm.summarizeSession(defaultAgent, "session-1") - events := collectEventStream(sub.C) - summaryEvt, ok := findEvent(events, EventKindSessionSummarize) + events := collectRuntimeEventStream(runtimeCh) + summaryEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentSessionSummarize) if !ok { t.Fatal("expected session summarize event") } @@ -721,21 +736,6 @@ func TestAgentLoop_EmitsFollowUpQueuedEvent(t *testing.T) { } } -func collectEventStream(ch <-chan Event) []Event { - var events []Event - for { - select { - case evt, ok := <-ch: - if !ok { - return events - } - events = append(events, evt) - default: - return events - } - } -} - func receiveLegacyEvent(t *testing.T, ch <-chan Event) Event { t.Helper() @@ -766,36 +766,6 @@ func receiveRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeeve } } -func waitForEvent(t *testing.T, ch <-chan Event, timeout time.Duration, match func(Event) bool) Event { - t.Helper() - - timer := time.NewTimer(timeout) - defer timer.Stop() - - for { - select { - case evt, ok := <-ch: - if !ok { - t.Fatal("event stream closed before expected event arrived") - } - if match(evt) { - return evt - } - case <-timer.C: - t.Fatal("timed out waiting for expected event") - } - } -} - -func findEvent(events []Event, kind EventKind) (Event, bool) { - for _, evt := range events { - if evt.Kind == kind { - return evt, true - } - } - return Event{}, false -} - type stringError string func (e stringError) Error() string { diff --git a/pkg/agent/hook_process_test.go b/pkg/agent/hook_process_test.go index 31f4ff7e4..f8d0d54f9 100644 --- a/pkg/agent/hook_process_test.go +++ b/pkg/agent/hook_process_test.go @@ -13,6 +13,7 @@ import ( "time" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/isolation" "github.com/sipeed/picoclaw/pkg/providers" ) @@ -146,8 +147,13 @@ func TestAgentLoop_MountProcessHook_ApprovalDeny(t *testing.T) { t.Fatalf("MountProcessHook failed: %v", err) } - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentToolExecSkipped, + ) + defer closeRuntimeEvents() resp, err := al.runAgentLoop(context.Background(), agent, processOptions{ SessionKey: "session-1", @@ -167,8 +173,8 @@ func TestAgentLoop_MountProcessHook_ApprovalDeny(t *testing.T) { t.Fatalf("expected %q, got %q", expected, resp) } - events := collectEventStream(sub.C) - skippedEvt, ok := findEvent(events, EventKindToolExecSkipped) + events := collectRuntimeEventStream(runtimeCh) + skippedEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentToolExecSkipped) if !ok { t.Fatal("expected tool skipped event") } diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index d835cdc7d..ac466c42d 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -885,8 +885,13 @@ func TestAgentLoop_Hooks_ToolApproverCanDeny(t *testing.T) { t.Fatalf("MountHook failed: %v", err) } - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentToolExecSkipped, + ) + defer closeRuntimeEvents() resp, err := al.runAgentLoop(context.Background(), agent, processOptions{ SessionKey: "session-1", @@ -905,8 +910,8 @@ func TestAgentLoop_Hooks_ToolApproverCanDeny(t *testing.T) { t.Fatalf("expected %q, got %q", expected, resp) } - events := collectEventStream(sub.C) - skippedEvt, ok := findEvent(events, EventKindToolExecSkipped) + events := collectRuntimeEventStream(runtimeCh) + skippedEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentToolExecSkipped) if !ok { t.Fatal("expected tool skipped event") } @@ -961,8 +966,13 @@ func TestAgentLoop_Hooks_ToolRespondAction(t *testing.T) { t.Fatalf("MountHook failed: %v", err) } - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentToolExecEnd, + ) + defer closeRuntimeEvents() resp, err := al.runAgentLoop(context.Background(), agent, processOptions{ SessionKey: "session-1", @@ -984,8 +994,8 @@ func TestAgentLoop_Hooks_ToolRespondAction(t *testing.T) { } // Verify event stream has ToolExecEnd, not actual tool execution - events := collectEventStream(sub.C) - endEvt, ok := findEvent(events, EventKindToolExecEnd) + events := collectRuntimeEventStream(runtimeCh) + endEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentToolExecEnd) if !ok { t.Fatal("expected tool exec end event") } @@ -1150,8 +1160,13 @@ func TestAgentLoop_HookRespond_MediaError(t *testing.T) { sendErr: errors.New("channel unavailable"), }) - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentToolExecEnd, + ) + defer closeRuntimeEvents() _, err := al.runAgentLoop(context.Background(), agent, processOptions{ SessionKey: "session-media-err", @@ -1166,8 +1181,8 @@ func TestAgentLoop_HookRespond_MediaError(t *testing.T) { t.Fatalf("runAgentLoop failed: %v", err) } - events := collectEventStream(sub.C) - endEvt, ok := findEvent(events, EventKindToolExecEnd) + events := collectRuntimeEventStream(runtimeCh) + endEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentToolExecEnd) if !ok { t.Fatal("expected ToolExecEnd event") } @@ -1205,8 +1220,13 @@ func TestAgentLoop_HookRespond_BusFallback(t *testing.T) { t.Fatalf("MountHook failed: %v", err) } - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentToolExecEnd, + ) + defer closeRuntimeEvents() resp, err := al.runAgentLoop(context.Background(), agent, processOptions{ SessionKey: "session-bus-fallback", @@ -1221,8 +1241,8 @@ func TestAgentLoop_HookRespond_BusFallback(t *testing.T) { t.Fatalf("runAgentLoop failed: %v", err) } - events := collectEventStream(sub.C) - endEvt, ok := findEvent(events, EventKindToolExecEnd) + events := collectRuntimeEventStream(runtimeCh) + endEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentToolExecEnd) if !ok { t.Fatal("expected ToolExecEnd event") } @@ -1367,8 +1387,13 @@ func TestAgentLoop_HookRespond_InterruptSkipsRemaining(t *testing.T) { t.Fatalf("MountHook failed: %v", err) } - sub := al.SubscribeEvents(32) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 32, + runtimeevents.KindAgentToolExecSkipped, + ) + defer closeRuntimeEvents() sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) @@ -1407,9 +1432,9 @@ func TestAgentLoop_HookRespond_InterruptSkipsRemaining(t *testing.T) { t.Fatal("timeout waiting for result") } - events := collectEventStream(sub.C) + events := collectRuntimeEventStream(runtimeCh) - skippedEvts := filterEvents(events, EventKindToolExecSkipped) + skippedEvts := filterRuntimeEvents(events, runtimeevents.KindAgentToolExecSkipped) if len(skippedEvts) < 1 { t.Fatal("expected at least one ToolExecSkipped event after interrupt") } @@ -1447,8 +1472,14 @@ func TestAgentLoop_HookRespond_SteeringSkipsRemaining(t *testing.T) { t.Fatalf("MountHook failed: %v", err) } - sub := al.SubscribeEvents(32) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 32, + runtimeevents.KindAgentToolExecEnd, + runtimeevents.KindAgentToolExecSkipped, + ) + defer closeRuntimeEvents() sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) @@ -1468,14 +1499,14 @@ func TestAgentLoop_HookRespond_SteeringSkipsRemaining(t *testing.T) { resultCh <- result{resp: resp, err: err} }() - collectedEvents := make([]Event, 0, 8) + collectedEvents := make([]runtimeevents.Event, 0, 8) steered := false deadline := time.After(3 * time.Second) for !steered { select { - case evt := <-sub.C: + case evt := <-runtimeCh: collectedEvents = append(collectedEvents, evt) - if evt.Kind != EventKindToolExecEnd { + if evt.Kind != runtimeevents.KindAgentToolExecEnd { continue } payload, ok := evt.Payload.(ToolExecEndPayload) @@ -1498,9 +1529,9 @@ func TestAgentLoop_HookRespond_SteeringSkipsRemaining(t *testing.T) { t.Fatal("timeout waiting for result") } - events := append(collectedEvents, collectEventStream(sub.C)...) + events := append(collectedEvents, collectRuntimeEventStream(runtimeCh)...) - skippedEvts := filterEvents(events, EventKindToolExecSkipped) + skippedEvts := filterRuntimeEvents(events, runtimeevents.KindAgentToolExecSkipped) if len(skippedEvts) < 1 { t.Fatal("expected at least one ToolExecSkipped event after steering") } @@ -1565,13 +1596,3 @@ func TestCloneStringAnyMap_EmptyMapReturnsNonNil(t *testing.T) { } }) } - -func filterEvents(events []Event, kind EventKind) []Event { - var result []Event - for _, evt := range events { - if evt.Kind == kind { - result = append(result, evt) - } - } - return result -} diff --git a/pkg/agent/runtime_event_test.go b/pkg/agent/runtime_event_test.go index 47fd6923a..162ccf424 100644 --- a/pkg/agent/runtime_event_test.go +++ b/pkg/agent/runtime_event_test.go @@ -64,3 +64,40 @@ func waitForRuntimeEvent( } } } + +func collectRuntimeEventStream(ch <-chan runtimeevents.Event) []runtimeevents.Event { + var events []runtimeevents.Event + for { + select { + case evt, ok := <-ch: + if !ok { + return events + } + events = append(events, evt) + default: + return events + } + } +} + +func findRuntimeEvent( + events []runtimeevents.Event, + kind runtimeevents.Kind, +) (runtimeevents.Event, bool) { + for _, evt := range events { + if evt.Kind == kind { + return evt, true + } + } + return runtimeevents.Event{}, false +} + +func filterRuntimeEvents(events []runtimeevents.Event, kind runtimeevents.Kind) []runtimeevents.Event { + var filtered []runtimeevents.Event + for _, evt := range events { + if evt.Kind == kind { + filtered = append(filtered, evt) + } + } + return filtered +} diff --git a/pkg/agent/steering_test.go b/pkg/agent/steering_test.go index bba988672..1e78fd56a 100644 --- a/pkg/agent/steering_test.go +++ b/pkg/agent/steering_test.go @@ -14,6 +14,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/media" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/routing" @@ -1134,8 +1135,14 @@ func TestAgentLoop_InterruptGraceful_UsesTerminalNoToolCall(t *testing.T) { al.RegisterTool(tool2) sessionKey := session.BuildMainSessionKey(routing.DefaultAgentID) - sub := al.SubscribeEvents(32) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 32, + runtimeevents.KindAgentInterruptReceived, + runtimeevents.KindAgentTurnEnd, + ) + defer closeRuntimeEvents() type result struct { resp string @@ -1222,8 +1229,8 @@ func TestAgentLoop_InterruptGraceful_UsesTerminalNoToolCall(t *testing.T) { t.Fatal("expected remaining tool to be marked as skipped after graceful interrupt") } - events := collectEventStream(sub.C) - interruptEvt, ok := findEvent(events, EventKindInterruptReceived) + events := collectRuntimeEventStream(runtimeCh) + interruptEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentInterruptReceived) if !ok { t.Fatal("expected interrupt received event") } @@ -1235,7 +1242,7 @@ func TestAgentLoop_InterruptGraceful_UsesTerminalNoToolCall(t *testing.T) { t.Fatalf("expected graceful interrupt payload, got %q", interruptPayload.Kind) } - turnEndEvt, ok := findEvent(events, EventKindTurnEnd) + turnEndEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentTurnEnd) if !ok { t.Fatal("expected turn end event") } @@ -1299,8 +1306,14 @@ func TestAgentLoop_InterruptHard_RestoresSession(t *testing.T) { } defaultAgent.Sessions.SetHistory(sessionKey, originalHistory) - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentInterruptReceived, + runtimeevents.KindAgentTurnEnd, + ) + defer closeRuntimeEvents() type result struct { resp string @@ -1353,8 +1366,8 @@ func TestAgentLoop_InterruptHard_RestoresSession(t *testing.T) { t.Fatalf("expected history rollback after hard abort, got %#v", finalHistory) } - events := collectEventStream(sub.C) - interruptEvt, ok := findEvent(events, EventKindInterruptReceived) + events := collectRuntimeEventStream(runtimeCh) + interruptEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentInterruptReceived) if !ok { t.Fatal("expected interrupt received event") } @@ -1366,7 +1379,7 @@ func TestAgentLoop_InterruptHard_RestoresSession(t *testing.T) { t.Fatalf("expected hard interrupt payload, got %q", interruptPayload.Kind) } - turnEndEvt, ok := findEvent(events, EventKindTurnEnd) + turnEndEvt, ok := findRuntimeEvent(events, runtimeevents.KindAgentTurnEnd) if !ok { t.Fatal("expected turn end event") } diff --git a/pkg/agent/subturn_test.go b/pkg/agent/subturn_test.go index 040063249..26cb28fb7 100644 --- a/pkg/agent/subturn_test.go +++ b/pkg/agent/subturn_test.go @@ -10,6 +10,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/tools" ) @@ -22,30 +23,38 @@ const ( // ====================== Test Helper: Event Collector ====================== type eventCollector struct { mu sync.Mutex - events []Event + events []runtimeevents.Event } func newEventCollector(t *testing.T, al *AgentLoop) (*eventCollector, func()) { t.Helper() c := &eventCollector{} - sub := al.SubscribeEvents(16) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentSubTurnSpawn, + runtimeevents.KindAgentSubTurnEnd, + runtimeevents.KindAgentSubTurnResultDelivered, + runtimeevents.KindAgentSubTurnOrphan, + ) done := make(chan struct{}) go func() { defer close(done) - for evt := range sub.C { + for evt := range runtimeCh { c.mu.Lock() c.events = append(c.events, evt) c.mu.Unlock() } }() cleanup := func() { - al.UnsubscribeEvents(sub.ID) + closeRuntimeEvents() <-done } return c, cleanup } -func (c *eventCollector) hasEventOfKind(kind EventKind) bool { +func (c *eventCollector) hasEventOfKind(kind runtimeevents.Kind) bool { c.mu.Lock() defer c.mu.Unlock() for _, e := range c.events { @@ -158,12 +167,12 @@ func TestSpawnSubTurn(t *testing.T) { // Verify event emission time.Sleep(10 * time.Millisecond) // let event goroutine flush if tt.wantSpawn { - if !collector.hasEventOfKind(EventKindSubTurnSpawn) { + if !collector.hasEventOfKind(runtimeevents.KindAgentSubTurnSpawn) { t.Error("SubTurnSpawnEvent not emitted") } } if tt.wantEnd { - if !collector.hasEventOfKind(EventKindSubTurnEnd) { + if !collector.hasEventOfKind(runtimeevents.KindAgentSubTurnEnd) { t.Error("SubTurnEndEvent not emitted") } } @@ -316,7 +325,7 @@ func TestSpawnSubTurn_OrphanResultRouting(t *testing.T) { time.Sleep(10 * time.Millisecond) // let event goroutine flush // Verify Orphan event is emitted - if !collector.hasEventOfKind(EventKindSubTurnOrphan) { + if !collector.hasEventOfKind(runtimeevents.KindAgentSubTurnOrphan) { t.Error("SubTurnOrphanResultEvent not emitted for finished parent") } @@ -591,12 +600,16 @@ func TestNestedSubTurnHierarchy(t *testing.T) { var spawnedTurns []turnInfo var mu sync.Mutex - // Subscribe to real EventBus to capture spawn events - sub := al.SubscribeEvents(16) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 16, + runtimeevents.KindAgentSubTurnSpawn, + ) + defer closeRuntimeEvents() go func() { - for evt := range sub.C { - if evt.Kind == EventKindSubTurnSpawn { + for evt := range runtimeCh { + if evt.Kind == runtimeevents.KindAgentSubTurnSpawn { p, _ := evt.Payload.(SubTurnSpawnPayload) mu.Lock() spawnedTurns = append(spawnedTurns, turnInfo{ @@ -879,7 +892,7 @@ func TestSpawnSubTurn_PanicRecovery(t *testing.T) { time.Sleep(10 * time.Millisecond) // let event goroutine flush // SubTurnEndEvent should still be emitted - if !collector.hasEventOfKind(EventKindSubTurnEnd) { + if !collector.hasEventOfKind(runtimeevents.KindAgentSubTurnEnd) { t.Error("SubTurnEndEvent not emitted after panic") } @@ -1229,18 +1242,23 @@ func TestDeliverSubTurnResult_RaceWithFinish(t *testing.T) { al, _, _, _, cleanup := newTestAgentLoop(t) //nolint:dogsled defer cleanup() - // Collect events via real EventBus var mu sync.Mutex var deliveredCount, orphanCount int - sub := al.SubscribeEvents(64) - defer al.UnsubscribeEvents(sub.ID) + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 64, + runtimeevents.KindAgentSubTurnResultDelivered, + runtimeevents.KindAgentSubTurnOrphan, + ) + defer closeRuntimeEvents() go func() { - for evt := range sub.C { + for evt := range runtimeCh { mu.Lock() switch evt.Kind { - case EventKindSubTurnResultDelivered: + case runtimeevents.KindAgentSubTurnResultDelivered: deliveredCount++ - case EventKindSubTurnOrphan: + case runtimeevents.KindAgentSubTurnOrphan: orphanCount++ } mu.Unlock() @@ -1795,13 +1813,20 @@ func TestAsyncSubTurn_ParentFinishesEarly(t *testing.T) { provider := &slowMockProvider{delay: 5 * time.Second} // SubTurn takes 5 seconds al := NewAgentLoop(cfg, msgBus, provider) - // Capture events via real EventBus var mu sync.Mutex - var events []Event - sub := al.SubscribeEvents(32) - defer al.UnsubscribeEvents(sub.ID) + var events []runtimeevents.Event + runtimeCh, closeRuntimeEvents := subscribeRuntimeEventsForTest( + t, + al, + 32, + runtimeevents.KindAgentSubTurnSpawn, + runtimeevents.KindAgentSubTurnEnd, + runtimeevents.KindAgentSubTurnResultDelivered, + runtimeevents.KindAgentSubTurnOrphan, + ) + defer closeRuntimeEvents() go func() { - for evt := range sub.C { + for evt := range runtimeCh { mu.Lock() events = append(events, evt) mu.Unlock() From 6e8a81bfbf2ec680fe028dd4ed45dc9bcd4ec5d5 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:28:41 +0800 Subject: [PATCH 17/53] test(events): prefer runtime hook observation Use RuntimeEventObserver for the normal in-process hook observer path and make the process-hook helper assert hook.runtime_event notifications. Validation: go test ./pkg/agent; make lint --- pkg/agent/hook_process_test.go | 5 +---- pkg/agent/hooks_test.go | 26 ++++++++++++-------------- pkg/agent/subturn_test.go | 2 +- 3 files changed, 14 insertions(+), 19 deletions(-) diff --git a/pkg/agent/hook_process_test.go b/pkg/agent/hook_process_test.go index f8d0d54f9..0fd1ec38d 100644 --- a/pkg/agent/hook_process_test.go +++ b/pkg/agent/hook_process_test.go @@ -356,14 +356,11 @@ func runProcessHookHelper() error { } if msg.ID == 0 { - if (msg.Method == "hook.event" || msg.Method == "hook.runtime_event") && eventLog != "" { + if msg.Method == "hook.runtime_event" && eventLog != "" { var evt map[string]any if err := json.Unmarshal(msg.Params, &evt); err == nil { if kind, ok := evt["kind"].(string); ok { _ = os.WriteFile(eventLog, []byte(kind+"\n"), 0o644) - } else if rawKind, ok := evt["Kind"].(float64); ok { - kind := EventKind(rawKind) - _ = os.WriteFile(eventLog, []byte(kind.String()+"\n"), 0o644) } } } diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index ac466c42d..592c32c1e 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -112,14 +112,14 @@ func (p *llmHookTestProvider) GetDefaultModel() string { } type llmObserverHook struct { - eventCh chan Event + eventCh chan runtimeevents.Event lastInbound *bus.InboundContext lastRoute *routing.ResolvedRoute lastScope *session.SessionScope } -func (h *llmObserverHook) OnEvent(ctx context.Context, evt Event) error { - if evt.Kind == EventKindTurnEnd { +func (h *llmObserverHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { + if evt.Kind == runtimeevents.KindAgentTurnEnd { select { case h.eventCh <- evt: default: @@ -443,7 +443,7 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { al, agent, cleanup := newHookTestLoop(t, provider) defer cleanup() - hook := &llmObserverHook{eventCh: make(chan Event, 1)} + hook := &llmObserverHook{eventCh: make(chan runtimeevents.Event, 1)} if err := al.MountHook(NamedHook("llm-observer", hook)); err != nil { t.Fatalf("MountHook failed: %v", err) } @@ -507,17 +507,15 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { select { case evt := <-hook.eventCh: - if evt.Kind != EventKindTurnEnd { + if evt.Kind != runtimeevents.KindAgentTurnEnd { t.Fatalf("expected turn end event, got %v", evt.Kind) } - if evt.Context == nil || evt.Context.Inbound == nil { - t.Fatal("expected observer event to carry inbound context") - } - if evt.Context.Route == nil || evt.Context.Route.AgentID != "main" { - t.Fatalf("expected observer event to carry route context, got %+v", evt.Context.Route) - } - if evt.Context.Scope == nil || evt.Context.Scope.Values["sender"] != "hook-user" { - t.Fatalf("expected observer event to carry session scope, got %+v", evt.Context.Scope) + if evt.Scope.AgentID != "main" || + evt.Scope.SessionKey != "session-1" || + evt.Scope.Channel != "cli" || + evt.Scope.ChatID != "direct" || + evt.Scope.SenderID != "hook-user" { + t.Fatalf("runtime observer scope = %+v", evt.Scope) } case <-time.After(2 * time.Second): t.Fatal("timed out waiting for hook observer event") @@ -589,7 +587,7 @@ func TestAgentLoop_BtwCommand_UsesLLMHooks(t *testing.T) { defer cleanup() useTestSideQuestionProvider(al, provider) - hook := &llmObserverHook{eventCh: make(chan Event, 1)} + hook := &llmObserverHook{eventCh: make(chan runtimeevents.Event, 1)} if err := al.MountHook(NamedHook("llm-observer", hook)); err != nil { t.Fatalf("MountHook failed: %v", err) } diff --git a/pkg/agent/subturn_test.go b/pkg/agent/subturn_test.go index 26cb28fb7..ac4184e7e 100644 --- a/pkg/agent/subturn_test.go +++ b/pkg/agent/subturn_test.go @@ -140,7 +140,7 @@ func TestSpawnSubTurn(t *testing.T) { agent: al.registry.GetDefaultAgent(), } - // Subscribe to real EventBus to capture events + // Subscribe to runtime events to capture sub-turn lifecycle. collector, collectCleanup := newEventCollector(t, al) defer collectCleanup() From b2249df3eae0b3b21fe9456d75d1f7ff6a517864 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:31:52 +0800 Subject: [PATCH 18/53] refactor(events): split agent event payload types Move agent domain event payload structs out of the legacy event envelope file so the remaining EventKind/Event/EventMeta compatibility layer can be removed independently later. Validation: go test ./pkg/agent; make lint --- pkg/agent/event_payloads.go | 171 ++++++++++++++++++++++++++++++++++++ pkg/agent/events.go | 168 ----------------------------------- 2 files changed, 171 insertions(+), 168 deletions(-) create mode 100644 pkg/agent/event_payloads.go diff --git a/pkg/agent/event_payloads.go b/pkg/agent/event_payloads.go new file mode 100644 index 000000000..18fcbd4a0 --- /dev/null +++ b/pkg/agent/event_payloads.go @@ -0,0 +1,171 @@ +package agent + +import "time" + +// TurnEndStatus describes the terminal state of a turn. +type TurnEndStatus string + +const ( + // TurnEndStatusCompleted indicates the turn finished normally. + TurnEndStatusCompleted TurnEndStatus = "completed" + // TurnEndStatusError indicates the turn ended because of an error. + TurnEndStatusError TurnEndStatus = "error" + // TurnEndStatusAborted indicates the turn was hard-aborted and rolled back. + TurnEndStatusAborted TurnEndStatus = "aborted" +) + +// TurnStartPayload describes the start of a turn. +type TurnStartPayload struct { + UserMessage string + MediaCount int +} + +// TurnEndPayload describes the completion of a turn. +type TurnEndPayload struct { + Status TurnEndStatus + Iterations int + Duration time.Duration + FinalContentLen int +} + +// LLMRequestPayload describes an outbound LLM request. +type LLMRequestPayload struct { + Model string + MessagesCount int + ToolsCount int + MaxTokens int + Temperature float64 +} + +// LLMResponsePayload describes an inbound LLM response. +type LLMResponsePayload struct { + ContentLen int + ToolCalls int + HasReasoning bool +} + +// LLMDeltaPayload describes a streamed LLM delta. +type LLMDeltaPayload struct { + ContentDeltaLen int + ReasoningDeltaLen int +} + +// LLMRetryPayload describes a retry of an LLM request. +type LLMRetryPayload struct { + Attempt int + MaxRetries int + Reason string + Error string + Backoff time.Duration +} + +// ContextCompressReason identifies why emergency compression ran. +type ContextCompressReason string + +const ( + // ContextCompressReasonProactive indicates compression before the first LLM call. + ContextCompressReasonProactive ContextCompressReason = "proactive_budget" + // ContextCompressReasonRetry indicates compression during context-error retry handling. + ContextCompressReasonRetry ContextCompressReason = "llm_retry" + // ContextCompressReasonSummarize indicates post-turn async summarization. + ContextCompressReasonSummarize ContextCompressReason = "summarize" +) + +// ContextCompressPayload describes a forced history compression. +type ContextCompressPayload struct { + Reason ContextCompressReason + DroppedMessages int + RemainingMessages int +} + +// SessionSummarizePayload describes a completed async session summarization. +type SessionSummarizePayload struct { + SummarizedMessages int + KeptMessages int + SummaryLen int + OmittedOversized bool +} + +// ToolExecStartPayload describes a tool execution request. +type ToolExecStartPayload struct { + Tool string + Arguments map[string]any +} + +// ToolExecEndPayload describes the outcome of a tool execution. +type ToolExecEndPayload struct { + Tool string + Duration time.Duration + ForLLMLen int + ForUserLen int + IsError bool + Async bool +} + +// ToolExecSkippedPayload describes a skipped tool call. +type ToolExecSkippedPayload struct { + Tool string + Reason string +} + +// SteeringInjectedPayload describes steering messages appended before the next LLM call. +type SteeringInjectedPayload struct { + Count int + TotalContentLen int +} + +// FollowUpQueuedPayload describes an async follow-up queued back into the inbound bus. +type FollowUpQueuedPayload struct { + SourceTool string + ContentLen int +} + +type InterruptKind string + +const ( + InterruptKindSteering InterruptKind = "steering" + InterruptKindGraceful InterruptKind = "graceful" + InterruptKindHard InterruptKind = "hard_abort" +) + +// InterruptReceivedPayload describes accepted turn-control input. +type InterruptReceivedPayload struct { + Kind InterruptKind + Role string + ContentLen int + QueueDepth int + HintLen int +} + +// SubTurnSpawnPayload describes the creation of a child turn. +type SubTurnSpawnPayload struct { + AgentID string + Label string + ParentTurnID string +} + +// SubTurnEndPayload describes the completion of a child turn. +type SubTurnEndPayload struct { + AgentID string + Status string +} + +// SubTurnResultDeliveredPayload describes delivery of a sub-turn result. +type SubTurnResultDeliveredPayload struct { + TargetChannel string + TargetChatID string + ContentLen int +} + +// SubTurnOrphanPayload describes a sub-turn result that could not be delivered. +type SubTurnOrphanPayload struct { + ParentTurnID string + ChildTurnID string + Reason string +} + +// ErrorPayload describes an execution error inside the agent loop. +type ErrorPayload struct { + Stage string + Message string +} diff --git a/pkg/agent/events.go b/pkg/agent/events.go index a2d466b9e..6b5603284 100644 --- a/pkg/agent/events.go +++ b/pkg/agent/events.go @@ -108,171 +108,3 @@ type EventMeta struct { Source string turnContext *TurnContext } - -// TurnEndStatus describes the terminal state of a turn. -type TurnEndStatus string - -const ( - // TurnEndStatusCompleted indicates the turn finished normally. - TurnEndStatusCompleted TurnEndStatus = "completed" - // TurnEndStatusError indicates the turn ended because of an error. - TurnEndStatusError TurnEndStatus = "error" - // TurnEndStatusAborted indicates the turn was hard-aborted and rolled back. - TurnEndStatusAborted TurnEndStatus = "aborted" -) - -// TurnStartPayload describes the start of a turn. -type TurnStartPayload struct { - UserMessage string - MediaCount int -} - -// TurnEndPayload describes the completion of a turn. -type TurnEndPayload struct { - Status TurnEndStatus - Iterations int - Duration time.Duration - FinalContentLen int -} - -// LLMRequestPayload describes an outbound LLM request. -type LLMRequestPayload struct { - Model string - MessagesCount int - ToolsCount int - MaxTokens int - Temperature float64 -} - -// LLMResponsePayload describes an inbound LLM response. -type LLMResponsePayload struct { - ContentLen int - ToolCalls int - HasReasoning bool -} - -// LLMDeltaPayload describes a streamed LLM delta. -type LLMDeltaPayload struct { - ContentDeltaLen int - ReasoningDeltaLen int -} - -// LLMRetryPayload describes a retry of an LLM request. -type LLMRetryPayload struct { - Attempt int - MaxRetries int - Reason string - Error string - Backoff time.Duration -} - -// ContextCompressReason identifies why emergency compression ran. -type ContextCompressReason string - -const ( - // ContextCompressReasonProactive indicates compression before the first LLM call. - ContextCompressReasonProactive ContextCompressReason = "proactive_budget" - // ContextCompressReasonRetry indicates compression during context-error retry handling. - ContextCompressReasonRetry ContextCompressReason = "llm_retry" - // ContextCompressReasonSummarize indicates post-turn async summarization. - ContextCompressReasonSummarize ContextCompressReason = "summarize" -) - -// ContextCompressPayload describes a forced history compression. -type ContextCompressPayload struct { - Reason ContextCompressReason - DroppedMessages int - RemainingMessages int -} - -// SessionSummarizePayload describes a completed async session summarization. -type SessionSummarizePayload struct { - SummarizedMessages int - KeptMessages int - SummaryLen int - OmittedOversized bool -} - -// ToolExecStartPayload describes a tool execution request. -type ToolExecStartPayload struct { - Tool string - Arguments map[string]any -} - -// ToolExecEndPayload describes the outcome of a tool execution. -type ToolExecEndPayload struct { - Tool string - Duration time.Duration - ForLLMLen int - ForUserLen int - IsError bool - Async bool -} - -// ToolExecSkippedPayload describes a skipped tool call. -type ToolExecSkippedPayload struct { - Tool string - Reason string -} - -// SteeringInjectedPayload describes steering messages appended before the next LLM call. -type SteeringInjectedPayload struct { - Count int - TotalContentLen int -} - -// FollowUpQueuedPayload describes an async follow-up queued back into the inbound bus. -type FollowUpQueuedPayload struct { - SourceTool string - ContentLen int -} - -type InterruptKind string - -const ( - InterruptKindSteering InterruptKind = "steering" - InterruptKindGraceful InterruptKind = "graceful" - InterruptKindHard InterruptKind = "hard_abort" -) - -// InterruptReceivedPayload describes accepted turn-control input. -type InterruptReceivedPayload struct { - Kind InterruptKind - Role string - ContentLen int - QueueDepth int - HintLen int -} - -// SubTurnSpawnPayload describes the creation of a child turn. -type SubTurnSpawnPayload struct { - AgentID string - Label string - ParentTurnID string -} - -// SubTurnEndPayload describes the completion of a child turn. -type SubTurnEndPayload struct { - AgentID string - Status string -} - -// SubTurnResultDeliveredPayload describes delivery of a sub-turn result. -type SubTurnResultDeliveredPayload struct { - TargetChannel string - TargetChatID string - ContentLen int -} - -// SubTurnOrphanPayload describes a sub-turn result that could not be delivered. -type SubTurnOrphanPayload struct { - ParentTurnID string - ChildTurnID string - Reason string -} - -// ErrorPayload describes an execution error inside the agent loop. -type ErrorPayload struct { - Stage string - Message string -} From fce800414dd4d608123ac525ea89866c7c95ee59 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:33:18 +0800 Subject: [PATCH 19/53] docs(events): align hook design with runtime observation Mark the original hook design as an early record and update observer examples to pkg/events runtime events and hook.runtime_event. Validation: make lint --- docs/design/hook-system-design.zh.md | 63 +++++++++++++++------------- 1 file changed, 34 insertions(+), 29 deletions(-) diff --git a/docs/design/hook-system-design.zh.md b/docs/design/hook-system-design.zh.md index ab5566bec..8f815934a 100644 --- a/docs/design/hook-system-design.zh.md +++ b/docs/design/hook-system-design.zh.md @@ -1,11 +1,15 @@ # PicoClaw Hook 系统设计（基于 `refactor/agent`） +> 当前状态：本文是 hook 系统的早期设计记录。事件系统升级后，观察型 hook 的主路径已经切到 +> `pkg/events.Event`、`RuntimeEventObserver` 和进程 hook 的 `hook.runtime_event`。 +> 文中提到的 `agent.Event`、`EventKind`、`hook.event` 只代表迁移期兼容层，不应作为新代码接口。 + ## 背景 本设计围绕两个议题展开： - `#1316`：把 agent loop 重构为事件驱动、可中断、可追加、可观测 -- `#1796`：在 EventBus 稳定后，把 hooks 设计为 EventBus 的 consumer，而不是重新发明一套事件模型 +- `#1796`：在 runtime event bus 稳定后，把 hooks 设计为事件 consumer，而不是重新发明一套事件模型 当前分支已经完成了第一步里的“事件系统基础”，但还没有真正的 hook 挂载层。因此这里的目标不是重新设计 event，而是在已有实现上补出一层可扩展、可拦截、可外挂的 HookManager。 @@ -52,8 +56,9 @@ pi-mono 的核心思路更接近当前分支： 当前分支已经具备 hook 系统的地基： -- `pkg/agent/events.go` 定义了稳定的 `EventKind`、`EventMeta` 和 payload -- `pkg/agent/eventbus.go` 提供了非阻塞 fan-out 的 `EventBus` +- `pkg/events` 定义 runtime event envelope、kind、scope、source、severity 和 fan-out bus +- `pkg/agent/event_payloads.go` 保留 agent domain payload +- `pkg/agent/eventbus.go` 只作为迁移期兼容层存在 - `pkg/agent/loop.go` 中的 `runTurn()` 已在 turn、llm、tool、interrupt、follow-up、summary 等节点发射事件 - `pkg/agent/steering.go` 已支持 steering、graceful interrupt、hard abort - `pkg/agent/turn.go` 已维护 turn phase、恢复点、active turn、abort 状态 @@ -62,7 +67,7 @@ pi-mono 的核心思路更接近当前分支： 当前分支还缺四件事： -- 没有 HookManager，只有 EventBus +- 没有 HookManager，只有旧 agent EventBus - 没有 Before/After LLM、Before/After Tool 这种同步拦截点 - 没有审批型 hook - 子 agent 仍走 `pkg/tools/SubagentManager + RunToolLoop`，没有接入 `pkg/agent` 的 turn tree 和事件流 @@ -73,19 +78,19 @@ pi-mono 的核心思路更接近当前分支： ## 设计原则 -- Hook 必须建立在 `pkg/agent` 的 EventBus 和 turn 上下文之上 -- EventBus 负责广播，HookManager 负责拦截，两者职责分离 +- Hook 必须建立在 `pkg/events` runtime event bus 和 turn 上下文之上 +- runtime event bus 负责广播，HookManager 负责拦截，两者职责分离 - 项目内挂载要简单，项目外挂载必须走 IPC - 观察型 hook 不能阻塞 loop；拦截型 hook 必须有超时 - 先覆盖主 turn，不把 sub-turn 一次做满 -- 不新增第二套用户事件命名系统，优先复用 `EventKind.String()` +- 不新增第二套用户事件命名系统，新观察点统一使用 `pkg/events.Kind` ## 总体架构 分成三层： -1. `EventBus` - 负责广播只读事件，现有实现直接复用 +1. `pkg/events` runtime event bus + 负责广播只读事件，覆盖 agent、channel、gateway、bus、MCP 等运行时组件 2. `HookManager` 负责管理 hook、排序、超时、错误隔离，并在 `runTurn()` 的明确检查点执行同步拦截 @@ -97,7 +102,7 @@ pi-mono 的核心思路更接近当前分支： 换句话说： -- EventBus 是“发生了什么” +- runtime event bus 是“发生了什么” - HookManager 是“谁能介入” - HookMount 是“这些 hook 从哪里来” @@ -113,11 +118,11 @@ pi-mono 的核心思路更接近当前分支： ```go type EventObserver interface { - OnEvent(ctx context.Context, evt agent.Event) error + OnRuntimeEvent(ctx context.Context, evt events.Event) error } ``` -这类 hook 直接订阅 EventBus 即可。 +这类 hook 直接订阅 runtime event bus 即可。旧 `OnEvent(ctx, agent.Event)` 仅用于迁移期兼容。 适用场景： @@ -156,7 +161,7 @@ type ToolApprover interface { ## 对外暴露的最小 hook 面 -V1 不需要把所有 EventKind 都变成可拦截点。 +V1 不需要把所有 runtime event kind 都变成可拦截点。 建议只开放这些同步 hook： @@ -168,19 +173,19 @@ V1 不需要把所有 EventKind 都变成可拦截点。 其余节点继续作为只读事件暴露： -- `turn_start` -- `turn_end` -- `llm_request` -- `llm_response` -- `tool_exec_start` -- `tool_exec_end` -- `tool_exec_skipped` -- `steering_injected` -- `follow_up_queued` -- `interrupt_received` -- `context_compress` -- `session_summarize` -- `error` +- `agent.turn.start` +- `agent.turn.end` +- `agent.llm.request` +- `agent.llm.response` +- `agent.tool.exec_start` +- `agent.tool.exec_end` +- `agent.tool.exec_skipped` +- `agent.steering.injected` +- `agent.follow_up.queued` +- `agent.interrupt.received` +- `agent.context.compress` +- `agent.session.summarize` +- `agent.error` `subturn_*` 在 V1 中保留名字，但不承诺一定触发，直到子 turn 迁移完成。 @@ -369,7 +374,7 @@ PicoClaw 启动外部进程，并在其 stdin/stdout 上跑协议。 ### 观察链路 ```text -runTurn() -> emitEvent() -> EventBus -> observers +runTurn() -> emitEvent() -> runtime event bus -> observers ``` ### 拦截链路 @@ -464,13 +469,13 @@ V1 不做复杂自动发现。 最适合 PicoClaw 当前分支的方案，不是直接复制 OpenClaw 的 hooks，也不是完整照搬 pi-mono 的 extension system，而是： -- 以现有 `EventBus` 为只读观察面 +- 以 `pkg/events` runtime event bus 为只读观察面 - 以新增 `HookManager` 为同步拦截面 - 项目内通过 Go 对象直接挂载 - 项目外通过 `stdio JSON-RPC` 进程通信挂载 这样做有三个好处： -- 和 `#1796` 一致，hooks 只是 EventBus 之上的消费层 +- 和 `#1796` 一致，hooks 只是 runtime event bus 之上的消费层 - 和当前 `refactor/agent` 实现一致，不需要推翻已有事件系统 - 同时满足“仓内简单挂载”和“仓外进程通信挂载”两个硬需求 From b954e6b8dc26dca2e7b460320ebf845d06bccdc6 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:39:35 +0800 Subject: [PATCH 20/53] refactor(events): remove legacy agent event bus Drop the old agent EventBus, SubscribeEvents/EventDrops public surface, legacy hook observer dispatch, and hook.event process notification path. Agent observations now flow through pkg/events runtime events. Validation: go test ./pkg/agent; make lint --- pkg/agent/agent.go | 12 +--- pkg/agent/agent_event.go | 35 ---------- pkg/agent/agent_init.go | 5 +- pkg/agent/eventbus.go | 128 ------------------------------------- pkg/agent/eventbus_test.go | 79 +---------------------- pkg/agent/hook_process.go | 13 ---- pkg/agent/hooks.go | 81 ++--------------------- pkg/agent/hooks_test.go | 20 +----- 8 files changed, 8 insertions(+), 365 deletions(-) delete mode 100644 pkg/agent/eventbus.go diff --git a/pkg/agent/agent.go b/pkg/agent/agent.go index 2bec6897f..7a9384a23 100644 --- a/pkg/agent/agent.go +++ b/pkg/agent/agent.go @@ -38,8 +38,7 @@ type AgentLoop struct { registry *AgentRegistry state *state.Manager - // Event system (from Incoming) - eventBus *EventBus + // Runtime event system runtimeEvents runtimeevents.Bus ownsRuntimeEvents bool hooks *HookManager @@ -286,9 +285,6 @@ func (al *AgentLoop) Close() { if al.hooks != nil { al.hooks.Close() } - if al.eventBus != nil { - al.eventBus.Close() - } if al.runtimeEvents != nil && al.ownsRuntimeEvents { if err := al.runtimeEvents.Close(); err != nil { logger.ErrorCF("agent", "Failed to close runtime event bus", @@ -303,12 +299,6 @@ func (al *AgentLoop) Close() { // UnmountHook removes a previously registered in-process hook. -// SubscribeEvents registers a subscriber for agent-loop events. - -// UnsubscribeEvents removes a previously registered event subscriber. - -// EventDrops returns the number of dropped events for the given kind. - type turnEventScope struct { agentID string sessionKey string diff --git a/pkg/agent/agent_event.go b/pkg/agent/agent_event.go index 6bbd275e5..5b9acfdb0 100644 --- a/pkg/agent/agent_event.go +++ b/pkg/agent/agent_event.go @@ -46,9 +46,6 @@ func (al *AgentLoop) emitEvent(kind EventKind, meta EventMeta, payload any) { al.logEvent(evt) - if al.eventBus != nil { - al.eventBus.Emit(evt) - } al.publishRuntimeEvent(evt) } @@ -165,38 +162,6 @@ func (al *AgentLoop) UnmountHook(name string) { al.hooks.Unmount(name) } -// SubscribeEvents registers a subscriber for agent-loop events. -// -// Deprecated: use RuntimeEvents for new event observation code. -func (al *AgentLoop) SubscribeEvents(buffer int) EventSubscription { - if al == nil || al.eventBus == nil { - ch := make(chan Event) - close(ch) - return EventSubscription{C: ch} - } - return al.eventBus.Subscribe(buffer) -} - -// UnsubscribeEvents removes a previously registered event subscriber. -// -// Deprecated: use the Subscription returned by RuntimeEvents instead. -func (al *AgentLoop) UnsubscribeEvents(id uint64) { - if al == nil || al.eventBus == nil { - return - } - al.eventBus.Unsubscribe(id) -} - -// EventDrops returns the number of dropped events for the given kind. -// -// Deprecated: use RuntimeEventStats for runtime event drop counters. -func (al *AgentLoop) EventDrops(kind EventKind) int64 { - if al == nil || al.eventBus == nil { - return 0 - } - return al.eventBus.Dropped(kind) -} - // RuntimeEvents returns the root runtime event channel. func (al *AgentLoop) RuntimeEvents() runtimeevents.EventChannel { if al == nil || al.runtimeEvents == nil { diff --git a/pkg/agent/agent_init.go b/pkg/agent/agent_init.go index 7ae844656..7ad884cfe 100644 --- a/pkg/agent/agent_init.go +++ b/pkg/agent/agent_init.go @@ -49,8 +49,6 @@ func NewAgentLoop( stateManager = state.NewManager(defaultAgent.Workspace) } - eventBus := NewEventBus() - // Determine worker pool size from config (default: 1 = sequential) workerPoolSize := cfg.Agents.Defaults.MaxParallelTurns if workerPoolSize <= 0 { @@ -62,7 +60,6 @@ func NewAgentLoop( cfg: cfg, registry: registry, state: stateManager, - eventBus: eventBus, fallback: fallbackChain, cmdRegistry: commands.NewRegistry(commands.BuiltinDefinitions()), steering: newSteeringQueue(parseSteeringMode(cfg.Agents.Defaults.SteeringMode)), @@ -79,7 +76,7 @@ func NewAgentLoop( al.ownsRuntimeEvents = true } al.providerFactory = providers.CreateProviderFromConfig - al.hooks = NewHookManagerWithRuntimeEvents(eventBus, al.runtimeEvents.Channel()) + al.hooks = NewHookManager(al.runtimeEvents.Channel()) configureHookManagerFromConfig(al.hooks, cfg) al.contextManager = al.resolveContextManager() diff --git a/pkg/agent/eventbus.go b/pkg/agent/eventbus.go deleted file mode 100644 index 54ada62fb..000000000 --- a/pkg/agent/eventbus.go +++ /dev/null @@ -1,128 +0,0 @@ -package agent - -import ( - "sync" - "sync/atomic" - "time" -) - -const defaultEventSubscriberBuffer = 16 - -// EventSubscription identifies a subscriber channel returned by EventBus.Subscribe. -// -// Deprecated: use pkg/events.Subscription from RuntimeEvents for new code. -type EventSubscription struct { - ID uint64 - C <-chan Event -} - -type eventSubscriber struct { - ch chan Event -} - -// EventBus is a lightweight multi-subscriber broadcaster for agent-loop events. -// -// Deprecated: use pkg/events.EventBus for new code. This legacy bus remains -// only while existing agent event consumers migrate. -type EventBus struct { - mu sync.RWMutex - subs map[uint64]eventSubscriber - nextID uint64 - closed bool - dropped [eventKindCount]atomic.Int64 -} - -// NewEventBus creates a new in-process event broadcaster. -// -// Deprecated: use events.NewBus for new runtime event publishers. -func NewEventBus() *EventBus { - return &EventBus{ - subs: make(map[uint64]eventSubscriber), - } -} - -// Subscribe registers a new subscriber with the requested channel buffer size. -// A non-positive buffer uses the default size. -func (b *EventBus) Subscribe(buffer int) EventSubscription { - if buffer <= 0 { - buffer = defaultEventSubscriberBuffer - } - - b.mu.Lock() - defer b.mu.Unlock() - - if b.closed { - ch := make(chan Event) - close(ch) - return EventSubscription{C: ch} - } - - b.nextID++ - id := b.nextID - ch := make(chan Event, buffer) - b.subs[id] = eventSubscriber{ch: ch} - return EventSubscription{ID: id, C: ch} -} - -// Unsubscribe removes a subscriber and closes its channel. -func (b *EventBus) Unsubscribe(id uint64) { - b.mu.Lock() - defer b.mu.Unlock() - - sub, ok := b.subs[id] - if !ok { - return - } - - delete(b.subs, id) - close(sub.ch) -} - -// Emit broadcasts an event to all current subscribers without blocking. -// When a subscriber channel is full, the event is dropped for that subscriber. -func (b *EventBus) Emit(evt Event) { - if evt.Time.IsZero() { - evt.Time = time.Now() - } - - b.mu.RLock() - defer b.mu.RUnlock() - - if b.closed { - return - } - - for _, sub := range b.subs { - select { - case sub.ch <- evt: - default: - if evt.Kind < eventKindCount { - b.dropped[evt.Kind].Add(1) - } - } - } -} - -// Dropped returns the number of dropped events for a given kind. -func (b *EventBus) Dropped(kind EventKind) int64 { - if kind >= eventKindCount { - return 0 - } - return b.dropped[kind].Load() -} - -// Close closes all subscriber channels and stops future broadcasts. -func (b *EventBus) Close() { - b.mu.Lock() - defer b.mu.Unlock() - - if b.closed { - return - } - - b.closed = true - for id, sub := range b.subs { - close(sub.ch) - delete(b.subs, id) - } -} diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index 87b1c68b1..b7678e87b 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -16,74 +16,17 @@ import ( "github.com/sipeed/picoclaw/pkg/tools" ) -func TestEventBus_SubscribeEmitUnsubscribeClose(t *testing.T) { - eventBus := NewEventBus() - sub := eventBus.Subscribe(1) - - eventBus.Emit(Event{ - Kind: EventKindTurnStart, - Meta: EventMeta{TurnID: "turn-1"}, - }) - - select { - case evt := <-sub.C: - if evt.Kind != EventKindTurnStart { - t.Fatalf("expected %v, got %v", EventKindTurnStart, evt.Kind) - } - if evt.Meta.TurnID != "turn-1" { - t.Fatalf("expected turn id turn-1, got %q", evt.Meta.TurnID) - } - case <-time.After(time.Second): - t.Fatal("timed out waiting for event") - } - - eventBus.Unsubscribe(sub.ID) - if _, ok := <-sub.C; ok { - t.Fatal("expected subscriber channel to be closed after unsubscribe") - } - - eventBus.Close() - closedSub := eventBus.Subscribe(1) - if _, ok := <-closedSub.C; ok { - t.Fatal("expected closed bus to return a closed subscriber channel") - } -} - -func TestEventBus_DropsWhenSubscriberIsFull(t *testing.T) { - eventBus := NewEventBus() - sub := eventBus.Subscribe(1) - defer eventBus.Unsubscribe(sub.ID) - - start := time.Now() - for i := 0; i < 1000; i++ { - eventBus.Emit(Event{Kind: EventKindLLMRequest}) - } - - if elapsed := time.Since(start); elapsed > 100*time.Millisecond { - t.Fatalf("Emit took too long with a blocked subscriber: %s", elapsed) - } - - if got := eventBus.Dropped(EventKindLLMRequest); got != 999 { - t.Fatalf("expected 999 dropped events, got %d", got) - } -} - -func TestAgentLoop_DualPublishesRuntimeEvents(t *testing.T) { +func TestAgentLoop_PublishesRuntimeEvents(t *testing.T) { runtimeBus := runtimeevents.NewBus() al := &AgentLoop{ - eventBus: NewEventBus(), runtimeEvents: runtimeBus, } - defer al.eventBus.Close() defer func() { if err := runtimeBus.Close(); err != nil { t.Errorf("runtime bus close failed: %v", err) } }() - legacySub := al.SubscribeEvents(1) - defer al.UnsubscribeEvents(legacySub.ID) - runtimeSub, runtimeCh, err := al.RuntimeEvents().OfKind(runtimeevents.KindAgentToolExecStart).SubscribeChan( context.Background(), runtimeevents.SubscribeOptions{Name: "runtime", Buffer: 1}, @@ -122,11 +65,6 @@ func TestAgentLoop_DualPublishesRuntimeEvents(t *testing.T) { ToolExecStartPayload{Tool: "mock_custom", Arguments: map[string]any{"task": "ping"}}, ) - legacyEvt := receiveLegacyEvent(t, legacySub.C) - if legacyEvt.Kind != EventKindToolExecStart { - t.Fatalf("legacy kind = %v, want %v", legacyEvt.Kind, EventKindToolExecStart) - } - runtimeEvt := receiveRuntimeEvent(t, runtimeCh) if runtimeEvt.Kind != runtimeevents.KindAgentToolExecStart { t.Fatalf("runtime kind = %q, want %q", runtimeEvt.Kind, runtimeevents.KindAgentToolExecStart) @@ -736,21 +674,6 @@ func TestAgentLoop_EmitsFollowUpQueuedEvent(t *testing.T) { } } -func receiveLegacyEvent(t *testing.T, ch <-chan Event) Event { - t.Helper() - - select { - case evt, ok := <-ch: - if !ok { - t.Fatal("legacy event stream closed before expected event arrived") - } - return evt - case <-time.After(time.Second): - t.Fatal("timed out waiting for legacy event") - return Event{} - } -} - func receiveRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { t.Helper() diff --git a/pkg/agent/hook_process.go b/pkg/agent/hook_process.go index 0ba5d8fc7..ce8e932d2 100644 --- a/pkg/agent/hook_process.go +++ b/pkg/agent/hook_process.go @@ -184,19 +184,6 @@ func (ph *ProcessHook) Close() error { return ph.closeErr } -func (ph *ProcessHook) OnEvent(ctx context.Context, evt Event) error { - if ph == nil || !ph.opts.Observe { - return nil - } - if len(ph.observeKinds) > 0 { - kind := runtimeKindForAgentEvent(evt.Kind).String() - if _, ok := ph.observeKinds[kind]; !ok { - return nil - } - } - return ph.notify(ctx, "hook.event", evt) -} - func (ph *ProcessHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { if ph == nil || !ph.opts.Observe { return nil diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index 0a6c6785a..79b72017d 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -72,11 +72,6 @@ func NamedHook(name string, hook any) HookRegistration { } } -type EventObserver interface { - // Deprecated: implement RuntimeEventObserver for new observation code. - OnEvent(ctx context.Context, evt Event) error -} - type RuntimeEventObserver interface { OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error } @@ -198,7 +193,6 @@ func (r *ToolResultHookResponse) Clone() *ToolResultHookResponse { } type HookManager struct { - eventBus *EventBus runtimeEvents runtimeevents.EventChannel observerTimeout time.Duration interceptorTimeout time.Duration @@ -208,37 +202,21 @@ type HookManager struct { hooks map[string]HookRegistration ordered []HookRegistration - sub EventSubscription - runtimeSub runtimeevents.Subscription - done chan struct{} - runtimeDone chan struct{} - runtimeObserveEnabled bool - closeOnce sync.Once + runtimeSub runtimeevents.Subscription + runtimeDone chan struct{} + closeOnce sync.Once } -func NewHookManager(eventBus *EventBus) *HookManager { - return NewHookManagerWithRuntimeEvents(eventBus, nil) -} - -func NewHookManagerWithRuntimeEvents(eventBus *EventBus, runtimeEvents runtimeevents.EventChannel) *HookManager { +func NewHookManager(runtimeEvents runtimeevents.EventChannel) *HookManager { hm := &HookManager{ - eventBus: eventBus, runtimeEvents: runtimeEvents, observerTimeout: defaultHookObserverTimeout, interceptorTimeout: defaultHookInterceptorTimeout, approvalTimeout: defaultHookApprovalTimeout, hooks: make(map[string]HookRegistration), - done: make(chan struct{}), runtimeDone: make(chan struct{}), } - if eventBus != nil { - hm.sub = eventBus.Subscribe(hookObserverBufferSize) - go hm.dispatchEvents() - } else { - close(hm.done) - } - if runtimeEvents != nil { sub, ch, err := runtimeEvents.SubscribeChan(context.Background(), runtimeevents.SubscribeOptions{ Name: "hook-manager-observer", @@ -251,7 +229,6 @@ func NewHookManagerWithRuntimeEvents(eventBus *EventBus, runtimeEvents runtimeev close(hm.runtimeDone) } else { hm.runtimeSub = sub - hm.runtimeObserveEnabled = true go hm.dispatchRuntimeEvents(ch) } } else { @@ -267,9 +244,6 @@ func (hm *HookManager) Close() { } hm.closeOnce.Do(func() { - if hm.eventBus != nil { - hm.eventBus.Unsubscribe(hm.sub.ID) - } if hm.runtimeSub != nil { if err := hm.runtimeSub.Close(); err != nil { logger.WarnCF("hooks", "Failed to close runtime event hook subscription", map[string]any{ @@ -277,7 +251,6 @@ func (hm *HookManager) Close() { }) } } - <-hm.done <-hm.runtimeDone hm.closeAllHooks() }) @@ -335,25 +308,6 @@ func (hm *HookManager) Unmount(name string) { hm.rebuildOrdered() } -func (hm *HookManager) dispatchEvents() { - defer close(hm.done) - - for evt := range hm.sub.C { - for _, reg := range hm.snapshotHooks() { - if hm.runtimeObserveEnabled { - if _, ok := reg.Hook.(RuntimeEventObserver); ok { - continue - } - } - observer, ok := reg.Hook.(EventObserver) - if !ok { - continue - } - hm.runObserver(reg.Name, observer, evt) - } - } -} - func (hm *HookManager) dispatchRuntimeEvents(ch <-chan runtimeevents.Event) { defer close(hm.runtimeDone) @@ -643,33 +597,6 @@ func (hm *HookManager) closeAllHooks() { hm.ordered = nil } -func (hm *HookManager) runObserver(name string, observer EventObserver, evt Event) { - ctx, cancel := context.WithTimeout(context.Background(), hm.observerTimeout) - defer cancel() - - done := make(chan error, 1) - go func() { - done <- observer.OnEvent(ctx, evt) - }() - - select { - case err := <-done: - if err != nil { - logger.WarnCF("hooks", "Event observer failed", map[string]any{ - "hook": name, - "event": evt.Kind.String(), - "error": err.Error(), - }) - } - case <-ctx.Done(): - logger.WarnCF("hooks", "Event observer timed out", map[string]any{ - "hook": name, - "event": evt.Kind.String(), - "timeout_ms": hm.observerTimeout.Milliseconds(), - }) - } -} - func (hm *HookManager) runRuntimeObserver( name string, observer RuntimeEventObserver, diff --git a/pkg/agent/hooks_test.go b/pkg/agent/hooks_test.go index 592c32c1e..4deef38c7 100644 --- a/pkg/agent/hooks_test.go +++ b/pkg/agent/hooks_test.go @@ -152,20 +152,9 @@ func (h *llmObserverHook) AfterLLM( } type dualRuntimeObserverHook struct { - legacyCh chan Event runtimeCh chan runtimeevents.Event } -func (h *dualRuntimeObserverHook) OnEvent(ctx context.Context, evt Event) error { - if evt.Kind == EventKindTurnEnd { - select { - case h.legacyCh <- evt: - default: - } - } - return nil -} - func (h *dualRuntimeObserverHook) OnRuntimeEvent(ctx context.Context, evt runtimeevents.Event) error { if evt.Kind == runtimeevents.KindAgentTurnEnd { select { @@ -522,13 +511,12 @@ func TestAgentLoop_Hooks_ObserverAndLLMInterceptor(t *testing.T) { } } -func TestAgentLoop_Hooks_RuntimeObserverPreferredOverLegacyObserver(t *testing.T) { +func TestAgentLoop_Hooks_RuntimeObserverReceivesEvents(t *testing.T) { provider := &llmHookTestProvider{} al, agent, cleanup := newHookTestLoop(t, provider) defer cleanup() hook := &dualRuntimeObserverHook{ - legacyCh: make(chan Event, 1), runtimeCh: make(chan runtimeevents.Event, 1), } if err := al.MountHook(NamedHook("runtime-observer", hook)); err != nil { @@ -573,12 +561,6 @@ func TestAgentLoop_Hooks_RuntimeObserverPreferredOverLegacyObserver(t *testing.T case <-time.After(2 * time.Second): t.Fatal("timed out waiting for runtime observer event") } - - select { - case evt := <-hook.legacyCh: - t.Fatalf("legacy observer unexpectedly received %v", evt.Kind) - case <-time.After(100 * time.Millisecond): - } } func TestAgentLoop_BtwCommand_UsesLLMHooks(t *testing.T) { From 795ee362ead99924e600618c6509b980494c698e Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 16:55:02 +0800 Subject: [PATCH 21/53] refactor(events): emit agent runtime events directly Remove the legacy EventKind/Event envelope mapping and let agent event emission build pkg/events.Event values directly. Keep HookMeta as the shared hook metadata shape and preserve legacy observe string aliases by mapping them to runtime event kinds. Validation: GOCACHE=/tmp/picoclaw-go-cache go test ./pkg/agent; make lint --- docs/architecture/hooks/README.md | 2 +- docs/architecture/hooks/README.zh.md | 2 +- docs/design/hook-system-design.zh.md | 15 ++-- pkg/agent/agent_event.go | 44 ++++++------ pkg/agent/context_legacy.go | 5 +- pkg/agent/event_kind_runtime.go | 48 ------------- pkg/agent/eventbus_test.go | 4 +- pkg/agent/events.go | 102 +-------------------------- pkg/agent/events_runtime.go | 58 +++++++-------- pkg/agent/hook_mount.go | 51 +++++++++++--- pkg/agent/hooks.go | 20 +++--- pkg/agent/pipeline_execute.go | 19 ++--- pkg/agent/pipeline_finalize.go | 3 +- pkg/agent/pipeline_llm.go | 13 ++-- pkg/agent/steering.go | 9 +-- pkg/agent/subturn.go | 13 ++-- pkg/agent/turn_context.go | 2 +- pkg/agent/turn_coord.go | 17 ++--- pkg/agent/turn_state.go | 4 +- 19 files changed, 162 insertions(+), 269 deletions(-) delete mode 100644 pkg/agent/event_kind_runtime.go diff --git a/docs/architecture/hooks/README.md b/docs/architecture/hooks/README.md index d9d5ece8f..06f1a2c07 100644 --- a/docs/architecture/hooks/README.md +++ b/docs/architecture/hooks/README.md @@ -13,7 +13,7 @@ The repository no longer ships standalone example source files. The Go and Pytho | Type | Interface | Stage | Can modify data | | --- | --- | --- | --- | -| Observer | `RuntimeEventObserver` / `EventObserver` | Runtime event bus broadcast | No | +| Observer | `RuntimeEventObserver` | Runtime event bus broadcast | No | | LLM interceptor | `LLMInterceptor` | `before_llm` / `after_llm` | Yes | | Tool interceptor | `ToolInterceptor` | `before_tool` / `after_tool` | Yes | | Tool approver | `ToolApprover` | `approve_tool` | No, returns allow/deny | diff --git a/docs/architecture/hooks/README.zh.md b/docs/architecture/hooks/README.zh.md index b9d45b386..1fff40832 100644 --- a/docs/architecture/hooks/README.zh.md +++ b/docs/architecture/hooks/README.zh.md @@ -13,7 +13,7 @@ | 类型 | 接口 | 作用阶段 | 能否改写 | | --- | --- | --- | --- | -| 观察型 | `RuntimeEventObserver` / `EventObserver` | runtime event bus 广播事件时 | 否 | +| 观察型 | `RuntimeEventObserver` | runtime event bus 广播事件时 | 否 | | LLM 拦截型 | `LLMInterceptor` | `before_llm` / `after_llm` | 是 | | Tool 拦截型 | `ToolInterceptor` | `before_tool` / `after_tool` | 是 | | Tool 审批型 | `ToolApprover` | `approve_tool` | 否，返回批准/拒绝 | diff --git a/docs/design/hook-system-design.zh.md b/docs/design/hook-system-design.zh.md index 8f815934a..b654112bf 100644 --- a/docs/design/hook-system-design.zh.md +++ b/docs/design/hook-system-design.zh.md @@ -2,7 +2,7 @@ > 当前状态：本文是 hook 系统的早期设计记录。事件系统升级后，观察型 hook 的主路径已经切到 > `pkg/events.Event`、`RuntimeEventObserver` 和进程 hook 的 `hook.runtime_event`。 -> 文中提到的 `agent.Event`、`EventKind`、`hook.event` 只代表迁移期兼容层，不应作为新代码接口。 +> 旧 `agent.Event`、`EventKind`、`hook.event` 兼容层已经删除。 ## 背景 @@ -58,19 +58,16 @@ pi-mono 的核心思路更接近当前分支： - `pkg/events` 定义 runtime event envelope、kind、scope、source、severity 和 fan-out bus - `pkg/agent/event_payloads.go` 保留 agent domain payload -- `pkg/agent/eventbus.go` 只作为迁移期兼容层存在 +- agent domain payload 保留在 `pkg/agent/event_payloads.go` - `pkg/agent/loop.go` 中的 `runTurn()` 已在 turn、llm、tool、interrupt、follow-up、summary 等节点发射事件 - `pkg/agent/steering.go` 已支持 steering、graceful interrupt、hard abort - `pkg/agent/turn.go` 已维护 turn phase、恢复点、active turn、abort 状态 ### 现有缺口 -当前分支还缺四件事： - -- 没有 HookManager，只有旧 agent EventBus -- 没有 Before/After LLM、Before/After Tool 这种同步拦截点 -- 没有审批型 hook -- 子 agent 仍走 `pkg/tools/SubagentManager + RunToolLoop`，没有接入 `pkg/agent` 的 turn tree 和事件流 +早期设计时的缺口包括 HookManager、Before/After LLM、Before/After Tool、审批型 hook +以及 sub-turn 接入。当前实现已经覆盖主 turn 的 HookManager、LLM/Tool 拦截和审批； +sub-turn 事件已接入 runtime event bus。 ### 一个关键现实 @@ -122,7 +119,7 @@ type EventObserver interface { } ``` -这类 hook 直接订阅 runtime event bus 即可。旧 `OnEvent(ctx, agent.Event)` 仅用于迁移期兼容。 +这类 hook 直接订阅 runtime event bus 即可。 适用场景： diff --git a/pkg/agent/agent_event.go b/pkg/agent/agent_event.go index 5b9acfdb0..d4174ced5 100644 --- a/pkg/agent/agent_event.go +++ b/pkg/agent/agent_event.go @@ -19,8 +19,8 @@ func (al *AgentLoop) newTurnEventScope(agentID, sessionKey string, turnCtx *Turn } } -func (ts turnEventScope) meta(iteration int, source, tracePath string) EventMeta { - return EventMeta{ +func (ts turnEventScope) meta(iteration int, source, tracePath string) HookMeta { + return HookMeta{ AgentID: ts.agentID, TurnID: ts.turnID, SessionKey: ts.sessionKey, @@ -31,41 +31,45 @@ func (ts turnEventScope) meta(iteration int, source, tracePath string) EventMeta } } -func (al *AgentLoop) emitEvent(kind EventKind, meta EventMeta, payload any) { - clonedMeta := cloneEventMeta(meta) - evt := Event{ - Kind: kind, - Meta: clonedMeta, - Context: cloneTurnContext(clonedMeta.turnContext), - Payload: payload, +func (al *AgentLoop) emitEvent(kind runtimeevents.Kind, meta HookMeta, payload any) { + clonedMeta := cloneHookMeta(meta) + eventCtx := cloneTurnContext(clonedMeta.turnContext) + evt := runtimeevents.Event{ + Kind: kind, + Source: runtimeevents.Source{Component: "agent", Name: clonedMeta.AgentID}, + Scope: runtimeScopeFromHookMeta(clonedMeta, eventCtx), + Correlation: runtimeCorrelationFromHookMeta(clonedMeta), + Severity: runtimeSeverityForAgentEvent(kind, payload), + Payload: payload, + Attrs: runtimeAttrsFromHookMeta(clonedMeta), } if al == nil { return } - al.logEvent(evt) + al.logEvent(evt, clonedMeta, eventCtx) al.publishRuntimeEvent(evt) } -func (al *AgentLoop) logEvent(evt Event) { +func (al *AgentLoop) logEvent(evt runtimeevents.Event, meta HookMeta, eventCtx *TurnContext) { fields := map[string]any{ "event_kind": evt.Kind.String(), - "agent_id": evt.Meta.AgentID, - "turn_id": evt.Meta.TurnID, - "session_key": evt.Meta.SessionKey, - "iteration": evt.Meta.Iteration, + "agent_id": meta.AgentID, + "turn_id": meta.TurnID, + "session_key": meta.SessionKey, + "iteration": meta.Iteration, } - if evt.Meta.TracePath != "" { - fields["trace"] = evt.Meta.TracePath + if meta.TracePath != "" { + fields["trace"] = meta.TracePath } - if evt.Meta.Source != "" { - fields["source"] = evt.Meta.Source + if meta.Source != "" { + fields["source"] = meta.Source } - appendEventContextFields(fields, evt.Context) + appendEventContextFields(fields, eventCtx) switch payload := evt.Payload.(type) { case TurnStartPayload: diff --git a/pkg/agent/context_legacy.go b/pkg/agent/context_legacy.go index 5644571fb..94ef5367d 100644 --- a/pkg/agent/context_legacy.go +++ b/pkg/agent/context_legacy.go @@ -7,6 +7,7 @@ import ( "sync" "time" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" ) @@ -41,7 +42,7 @@ func (m *legacyContextManager) Compact(_ context.Context, req *CompactRequest) e // Sync emergency compression — budget exceeded. if result, ok := m.forceCompression(req.SessionKey); ok { m.al.emitEvent( - EventKindContextCompress, + runtimeevents.KindAgentContextCompress, m.al.newTurnEventScope("", req.SessionKey, nil).meta(0, "forceCompression", "turn.context.compress"), ContextCompressPayload{ Reason: req.Reason, @@ -246,7 +247,7 @@ func (m *legacyContextManager) summarizeSession(agent *AgentInstance, sessionKey agent.Sessions.TruncateHistory(sessionKey, keepCount) agent.Sessions.Save(sessionKey) m.al.emitEvent( - EventKindSessionSummarize, + runtimeevents.KindAgentSessionSummarize, m.al.newTurnEventScope(agent.ID, sessionKey, nil).meta(0, "summarizeSession", "turn.session.summarize"), SessionSummarizePayload{ SummarizedMessages: len(validMessages), diff --git a/pkg/agent/event_kind_runtime.go b/pkg/agent/event_kind_runtime.go deleted file mode 100644 index 031f3b35e..000000000 --- a/pkg/agent/event_kind_runtime.go +++ /dev/null @@ -1,48 +0,0 @@ -package agent - -import runtimeevents "github.com/sipeed/picoclaw/pkg/events" - -func runtimeKindForAgentEvent(kind EventKind) runtimeevents.Kind { - switch kind { - case EventKindTurnStart: - return runtimeevents.KindAgentTurnStart - case EventKindTurnEnd: - return runtimeevents.KindAgentTurnEnd - case EventKindLLMRequest: - return runtimeevents.KindAgentLLMRequest - case EventKindLLMDelta: - return runtimeevents.KindAgentLLMDelta - case EventKindLLMResponse: - return runtimeevents.KindAgentLLMResponse - case EventKindLLMRetry: - return runtimeevents.KindAgentLLMRetry - case EventKindContextCompress: - return runtimeevents.KindAgentContextCompress - case EventKindSessionSummarize: - return runtimeevents.KindAgentSessionSummarize - case EventKindToolExecStart: - return runtimeevents.KindAgentToolExecStart - case EventKindToolExecEnd: - return runtimeevents.KindAgentToolExecEnd - case EventKindToolExecSkipped: - return runtimeevents.KindAgentToolExecSkipped - case EventKindSteeringInjected: - return runtimeevents.KindAgentSteeringInjected - case EventKindFollowUpQueued: - return runtimeevents.KindAgentFollowUpQueued - case EventKindInterruptReceived: - return runtimeevents.KindAgentInterruptReceived - case EventKindSubTurnSpawn: - return runtimeevents.KindAgentSubTurnSpawn - case EventKindSubTurnEnd: - return runtimeevents.KindAgentSubTurnEnd - case EventKindSubTurnResultDelivered: - return runtimeevents.KindAgentSubTurnResultDelivered - case EventKindSubTurnOrphan: - return runtimeevents.KindAgentSubTurnOrphan - case EventKindError: - return runtimeevents.KindAgentError - default: - return runtimeevents.Kind("agent." + kind.String()) - } -} diff --git a/pkg/agent/eventbus_test.go b/pkg/agent/eventbus_test.go index b7678e87b..86d7f4afa 100644 --- a/pkg/agent/eventbus_test.go +++ b/pkg/agent/eventbus_test.go @@ -41,8 +41,8 @@ func TestAgentLoop_PublishesRuntimeEvents(t *testing.T) { }() al.emitEvent( - EventKindToolExecStart, - EventMeta{ + runtimeevents.KindAgentToolExecStart, + HookMeta{ AgentID: "main", TurnID: "turn-1", ParentTurnID: "parent-turn", diff --git a/pkg/agent/events.go b/pkg/agent/events.go index 6b5603284..0dd861f43 100644 --- a/pkg/agent/events.go +++ b/pkg/agent/events.go @@ -1,104 +1,8 @@ package agent -import ( - "fmt" - "time" -) - -// EventKind identifies a structured agent-loop event. -// -// Deprecated: use github.com/sipeed/picoclaw/pkg/events.Kind for new runtime -// event consumers. This legacy kind exists only during the runtime event -// migration window. -type EventKind uint8 - -const ( - // EventKindTurnStart is emitted when a turn begins processing. - EventKindTurnStart EventKind = iota - // EventKindTurnEnd is emitted when a turn finishes, successfully or with an error. - EventKindTurnEnd - // EventKindLLMRequest is emitted before a provider chat request is made. - EventKindLLMRequest - // EventKindLLMDelta is emitted when a streaming provider yields a partial delta. - EventKindLLMDelta - // EventKindLLMResponse is emitted after a provider chat response is received. - EventKindLLMResponse - // EventKindLLMRetry is emitted when an LLM request is retried. - EventKindLLMRetry - // EventKindContextCompress is emitted when session history is forcibly compressed. - EventKindContextCompress - // EventKindSessionSummarize is emitted when asynchronous summarization completes. - EventKindSessionSummarize - // EventKindToolExecStart is emitted immediately before a tool executes. - EventKindToolExecStart - // EventKindToolExecEnd is emitted immediately after a tool finishes executing. - EventKindToolExecEnd - // EventKindToolExecSkipped is emitted when a queued tool call is skipped. - EventKindToolExecSkipped - // EventKindSteeringInjected is emitted when queued steering is injected into context. - EventKindSteeringInjected - // EventKindFollowUpQueued is emitted when an async tool queues a follow-up system message. - EventKindFollowUpQueued - // EventKindInterruptReceived is emitted when a soft interrupt message is accepted. - EventKindInterruptReceived - // EventKindSubTurnSpawn is emitted when a sub-turn is spawned. - EventKindSubTurnSpawn - // EventKindSubTurnEnd is emitted when a sub-turn finishes. - EventKindSubTurnEnd - // EventKindSubTurnResultDelivered is emitted when a sub-turn result is delivered. - EventKindSubTurnResultDelivered - // EventKindSubTurnOrphan is emitted when a sub-turn result cannot be delivered. - EventKindSubTurnOrphan - // EventKindError is emitted when a turn encounters an execution error. - EventKindError - - eventKindCount -) - -var eventKindNames = [...]string{ - "turn_start", - "turn_end", - "llm_request", - "llm_delta", - "llm_response", - "llm_retry", - "context_compress", - "session_summarize", - "tool_exec_start", - "tool_exec_end", - "tool_exec_skipped", - "steering_injected", - "follow_up_queued", - "interrupt_received", - "subturn_spawn", - "subturn_end", - "subturn_result_delivered", - "subturn_orphan", - "error", -} - -// String returns the stable string form of an EventKind. -func (k EventKind) String() string { - if k >= eventKindCount { - return fmt.Sprintf("event_kind(%d)", k) - } - return eventKindNames[k] -} - -// Event is the structured envelope broadcast by the agent EventBus. -// -// Deprecated: use github.com/sipeed/picoclaw/pkg/events.Event for new -// observation code. Agent payload types remain supported. -type Event struct { - Kind EventKind - Time time.Time - Meta EventMeta - Context *TurnContext - Payload any -} - -// EventMeta contains correlation fields shared by all agent-loop events. -type EventMeta struct { +// HookMeta contains correlation fields shared by agent hook requests and +// runtime events emitted from turn processing. +type HookMeta struct { AgentID string TurnID string ParentTurnID string diff --git a/pkg/agent/events_runtime.go b/pkg/agent/events_runtime.go index 822c7e23a..b530f6161 100644 --- a/pkg/agent/events_runtime.go +++ b/pkg/agent/events_runtime.go @@ -9,7 +9,7 @@ import ( const runtimeEventPublishTimeout = 100 * time.Millisecond -func (al *AgentLoop) publishRuntimeEvent(evt Event) { +func (al *AgentLoop) publishRuntimeEvent(evt runtimeevents.Event) { if al == nil || al.runtimeEvents == nil { return } @@ -17,29 +17,21 @@ func (al *AgentLoop) publishRuntimeEvent(evt Event) { ctx, cancel := context.WithTimeout(context.Background(), runtimeEventPublishTimeout) defer cancel() - al.runtimeEvents.Publish(ctx, runtimeevents.Event{ - Kind: runtimeKindForAgentEvent(evt.Kind), - Source: runtimeevents.Source{Component: "agent", Name: evt.Meta.AgentID}, - Scope: runtimeScopeFromAgentEvent(evt), - Correlation: runtimeCorrelationFromAgentEvent(evt), - Severity: runtimeSeverityForAgentEvent(evt), - Payload: evt.Payload, - Attrs: runtimeAttrsFromAgentEvent(evt), - }) + al.runtimeEvents.Publish(ctx, evt) } -func runtimeScopeFromAgentEvent(evt Event) runtimeevents.Scope { +func runtimeScopeFromHookMeta(meta HookMeta, eventCtx *TurnContext) runtimeevents.Scope { scope := runtimeevents.Scope{ - AgentID: evt.Meta.AgentID, - SessionKey: evt.Meta.SessionKey, - TurnID: evt.Meta.TurnID, + AgentID: meta.AgentID, + SessionKey: meta.SessionKey, + TurnID: meta.TurnID, } - if evt.Context == nil || evt.Context.Inbound == nil { + if eventCtx == nil || eventCtx.Inbound == nil { return scope } - inbound := evt.Context.Inbound + inbound := eventCtx.Inbound scope.Channel = inbound.Channel scope.Account = inbound.Account scope.ChatID = inbound.ChatID @@ -52,21 +44,23 @@ func runtimeScopeFromAgentEvent(evt Event) runtimeevents.Scope { return scope } -func runtimeCorrelationFromAgentEvent(evt Event) runtimeevents.Correlation { +func runtimeCorrelationFromHookMeta(meta HookMeta) runtimeevents.Correlation { return runtimeevents.Correlation{ - TraceID: evt.Meta.TracePath, - ParentTurnID: evt.Meta.ParentTurnID, + TraceID: meta.TracePath, + ParentTurnID: meta.ParentTurnID, } } -func runtimeSeverityForAgentEvent(evt Event) runtimeevents.Severity { - switch evt.Kind { - case EventKindError, EventKindSubTurnOrphan: +func runtimeSeverityForAgentEvent(kind runtimeevents.Kind, payload any) runtimeevents.Severity { + switch kind { + case runtimeevents.KindAgentError, runtimeevents.KindAgentSubTurnOrphan: return runtimeevents.SeverityError - case EventKindLLMRetry, EventKindContextCompress, EventKindToolExecSkipped: + case runtimeevents.KindAgentLLMRetry, + runtimeevents.KindAgentContextCompress, + runtimeevents.KindAgentToolExecSkipped: return runtimeevents.SeverityWarn - case EventKindTurnEnd: - payload, ok := evt.Payload.(TurnEndPayload) + case runtimeevents.KindAgentTurnEnd: + payload, ok := payload.(TurnEndPayload) if !ok { return runtimeevents.SeverityInfo } @@ -78,8 +72,8 @@ func runtimeSeverityForAgentEvent(evt Event) runtimeevents.Severity { default: return runtimeevents.SeverityInfo } - case EventKindToolExecEnd: - payload, ok := evt.Payload.(ToolExecEndPayload) + case runtimeevents.KindAgentToolExecEnd: + payload, ok := payload.(ToolExecEndPayload) if ok && payload.IsError { return runtimeevents.SeverityWarn } @@ -89,13 +83,13 @@ func runtimeSeverityForAgentEvent(evt Event) runtimeevents.Severity { } } -func runtimeAttrsFromAgentEvent(evt Event) map[string]any { +func runtimeAttrsFromHookMeta(meta HookMeta) map[string]any { attrs := make(map[string]any, 2) - if evt.Meta.Source != "" { - attrs["agent_source"] = evt.Meta.Source + if meta.Source != "" { + attrs["agent_source"] = meta.Source } - if evt.Meta.Iteration != 0 { - attrs["iteration"] = evt.Meta.Iteration + if meta.Iteration != 0 { + attrs["iteration"] = meta.Iteration } if len(attrs) == 0 { return nil diff --git a/pkg/agent/hook_mount.go b/pkg/agent/hook_mount.go index dc002a508..409d56b32 100644 --- a/pkg/agent/hook_mount.go +++ b/pkg/agent/hook_mount.go @@ -311,14 +311,49 @@ func processHookObserveKindsFromConfig(observe []string) ([]string, bool, error) } func validHookEventKinds() map[string]string { - kinds := make(map[string]string, int(eventKindCount)*2) - for kind := EventKind(0); kind < eventKindCount; kind++ { - runtimeKind := runtimeKindForAgentEvent(kind).String() - kinds[kind.String()] = runtimeKind - kinds[runtimeKind] = runtimeKind + runtimeKinds := []runtimeevents.Kind{ + runtimeevents.KindAgentTurnStart, + runtimeevents.KindAgentTurnEnd, + runtimeevents.KindAgentLLMRequest, + runtimeevents.KindAgentLLMDelta, + runtimeevents.KindAgentLLMResponse, + runtimeevents.KindAgentLLMRetry, + runtimeevents.KindAgentContextCompress, + runtimeevents.KindAgentSessionSummarize, + runtimeevents.KindAgentToolExecStart, + runtimeevents.KindAgentToolExecEnd, + runtimeevents.KindAgentToolExecSkipped, + runtimeevents.KindAgentSteeringInjected, + runtimeevents.KindAgentFollowUpQueued, + runtimeevents.KindAgentInterruptReceived, + runtimeevents.KindAgentSubTurnSpawn, + runtimeevents.KindAgentSubTurnEnd, + runtimeevents.KindAgentSubTurnResultDelivered, + runtimeevents.KindAgentSubTurnOrphan, + runtimeevents.KindAgentError, } - kinds[runtimeevents.KindAgentToolExecStart.String()] = runtimeevents.KindAgentToolExecStart.String() - kinds[runtimeevents.KindAgentToolExecEnd.String()] = runtimeevents.KindAgentToolExecEnd.String() - kinds[runtimeevents.KindAgentToolExecSkipped.String()] = runtimeevents.KindAgentToolExecSkipped.String() + kinds := make(map[string]string, len(runtimeKinds)*2) + for _, kind := range runtimeKinds { + kinds[kind.String()] = kind.String() + } + kinds["turn_start"] = runtimeevents.KindAgentTurnStart.String() + kinds["turn_end"] = runtimeevents.KindAgentTurnEnd.String() + kinds["llm_request"] = runtimeevents.KindAgentLLMRequest.String() + kinds["llm_delta"] = runtimeevents.KindAgentLLMDelta.String() + kinds["llm_response"] = runtimeevents.KindAgentLLMResponse.String() + kinds["llm_retry"] = runtimeevents.KindAgentLLMRetry.String() + kinds["context_compress"] = runtimeevents.KindAgentContextCompress.String() + kinds["session_summarize"] = runtimeevents.KindAgentSessionSummarize.String() + kinds["tool_exec_start"] = runtimeevents.KindAgentToolExecStart.String() + kinds["tool_exec_end"] = runtimeevents.KindAgentToolExecEnd.String() + kinds["tool_exec_skipped"] = runtimeevents.KindAgentToolExecSkipped.String() + kinds["steering_injected"] = runtimeevents.KindAgentSteeringInjected.String() + kinds["follow_up_queued"] = runtimeevents.KindAgentFollowUpQueued.String() + kinds["interrupt_received"] = runtimeevents.KindAgentInterruptReceived.String() + kinds["subturn_spawn"] = runtimeevents.KindAgentSubTurnSpawn.String() + kinds["subturn_end"] = runtimeevents.KindAgentSubTurnEnd.String() + kinds["subturn_result_delivered"] = runtimeevents.KindAgentSubTurnResultDelivered.String() + kinds["subturn_orphan"] = runtimeevents.KindAgentSubTurnOrphan.String() + kinds["error"] = runtimeevents.KindAgentError.String() return kinds } diff --git a/pkg/agent/hooks.go b/pkg/agent/hooks.go index 79b72017d..a4f0fac82 100644 --- a/pkg/agent/hooks.go +++ b/pkg/agent/hooks.go @@ -91,7 +91,7 @@ type ToolApprover interface { } type LLMHookRequest struct { - Meta EventMeta `json:"meta"` + Meta HookMeta `json:"meta"` Context *TurnContext `json:"context,omitempty"` Model string `json:"model"` Messages []providers.Message `json:"messages,omitempty"` @@ -105,7 +105,7 @@ func (r *LLMHookRequest) Clone() *LLMHookRequest { return nil } cloned := *r - cloned.Meta = cloneEventMeta(r.Meta) + cloned.Meta = cloneHookMeta(r.Meta) cloned.Context = cloneTurnContext(r.Context) cloned.Messages = cloneProviderMessages(r.Messages) cloned.Tools = cloneToolDefinitions(r.Tools) @@ -114,7 +114,7 @@ func (r *LLMHookRequest) Clone() *LLMHookRequest { } type LLMHookResponse struct { - Meta EventMeta `json:"meta"` + Meta HookMeta `json:"meta"` Context *TurnContext `json:"context,omitempty"` Model string `json:"model"` Response *providers.LLMResponse `json:"response,omitempty"` @@ -125,14 +125,14 @@ func (r *LLMHookResponse) Clone() *LLMHookResponse { return nil } cloned := *r - cloned.Meta = cloneEventMeta(r.Meta) + cloned.Meta = cloneHookMeta(r.Meta) cloned.Context = cloneTurnContext(r.Context) cloned.Response = cloneLLMResponse(r.Response) return &cloned } type ToolCallHookRequest struct { - Meta EventMeta `json:"meta"` + Meta HookMeta `json:"meta"` Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` @@ -146,7 +146,7 @@ func (r *ToolCallHookRequest) Clone() *ToolCallHookRequest { return nil } cloned := *r - cloned.Meta = cloneEventMeta(r.Meta) + cloned.Meta = cloneHookMeta(r.Meta) cloned.Context = cloneTurnContext(r.Context) cloned.Arguments = cloneStringAnyMap(r.Arguments) cloned.HookResult = cloneToolResult(r.HookResult) @@ -154,7 +154,7 @@ func (r *ToolCallHookRequest) Clone() *ToolCallHookRequest { } type ToolApprovalRequest struct { - Meta EventMeta `json:"meta"` + Meta HookMeta `json:"meta"` Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` @@ -165,14 +165,14 @@ func (r *ToolApprovalRequest) Clone() *ToolApprovalRequest { return nil } cloned := *r - cloned.Meta = cloneEventMeta(r.Meta) + cloned.Meta = cloneHookMeta(r.Meta) cloned.Context = cloneTurnContext(r.Context) cloned.Arguments = cloneStringAnyMap(r.Arguments) return &cloned } type ToolResultHookResponse struct { - Meta EventMeta `json:"meta"` + Meta HookMeta `json:"meta"` Context *TurnContext `json:"context,omitempty"` Tool string `json:"tool"` Arguments map[string]any `json:"arguments,omitempty"` @@ -185,7 +185,7 @@ func (r *ToolResultHookResponse) Clone() *ToolResultHookResponse { return nil } cloned := *r - cloned.Meta = cloneEventMeta(r.Meta) + cloned.Meta = cloneHookMeta(r.Meta) cloned.Context = cloneTurnContext(r.Context) cloned.Arguments = cloneStringAnyMap(r.Arguments) cloned.Result = cloneToolResult(r.Result) diff --git a/pkg/agent/pipeline_execute.go b/pkg/agent/pipeline_execute.go index 0cf3eaa9a..1f8430edd 100644 --- a/pkg/agent/pipeline_execute.go +++ b/pkg/agent/pipeline_execute.go @@ -10,6 +10,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/constants" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/tools" @@ -72,7 +73,7 @@ toolLoop: }) al.emitEvent( - EventKindToolExecStart, + runtimeevents.KindAgentToolExecStart, ts.eventMeta("runTurn", "turn.tool.start"), ToolExecStartPayload{ Tool: toolName, @@ -192,7 +193,7 @@ toolLoop: } al.emitEvent( - EventKindToolExecEnd, + runtimeevents.KindAgentToolExecEnd, ts.eventMeta("runTurn", "turn.tool.end"), ToolExecEndPayload{ Tool: toolName, @@ -238,7 +239,7 @@ toolLoop: for j := i + 1; j < len(normalizedToolCalls); j++ { skippedTC := normalizedToolCalls[j] al.emitEvent( - EventKindToolExecSkipped, + runtimeevents.KindAgentToolExecSkipped, ts.eventMeta("runTurn", "turn.tool.skipped"), ToolExecSkippedPayload{ Tool: skippedTC.Name, @@ -285,7 +286,7 @@ toolLoop: exec.allResponsesHandled = false denyContent := hookDeniedToolContent("Tool execution denied by hook", decision.Reason) al.emitEvent( - EventKindToolExecSkipped, + runtimeevents.KindAgentToolExecSkipped, ts.eventMeta("runTurn", "turn.tool.skipped"), ToolExecSkippedPayload{ Tool: toolName, @@ -324,7 +325,7 @@ toolLoop: exec.allResponsesHandled = false denyContent := hookDeniedToolContent("Tool execution denied by approval hook", approval.Reason) al.emitEvent( - EventKindToolExecSkipped, + runtimeevents.KindAgentToolExecSkipped, ts.eventMeta("runTurn", "turn.tool.skipped"), ToolExecSkippedPayload{ Tool: toolName, @@ -354,7 +355,7 @@ toolLoop: "iteration": iteration, }) al.emitEvent( - EventKindToolExecStart, + runtimeevents.KindAgentToolExecStart, ts.eventMeta("runTurn", "turn.tool.start"), ToolExecStartPayload{ Tool: toolName, @@ -403,7 +404,7 @@ toolLoop: "channel": ts.channel, }) al.emitEvent( - EventKindFollowUpQueued, + runtimeevents.KindAgentFollowUpQueued, ts.scope.meta(iteration, "runTurn", "turn.follow_up.queued"), FollowUpQueuedPayload{ SourceTool: asyncToolName, @@ -569,7 +570,7 @@ toolLoop: toolResultMsg.Media = append(toolResultMsg.Media, toolResult.Media...) } al.emitEvent( - EventKindToolExecEnd, + runtimeevents.KindAgentToolExecEnd, ts.eventMeta("runTurn", "turn.tool.end"), ToolExecEndPayload{ Tool: toolName, @@ -614,7 +615,7 @@ toolLoop: for j := i + 1; j < len(normalizedToolCalls); j++ { skippedTC := normalizedToolCalls[j] al.emitEvent( - EventKindToolExecSkipped, + runtimeevents.KindAgentToolExecSkipped, ts.eventMeta("runTurn", "turn.tool.skipped"), ToolExecSkippedPayload{ Tool: skippedTC.Name, diff --git a/pkg/agent/pipeline_finalize.go b/pkg/agent/pipeline_finalize.go index a2be6f65b..1f407825e 100644 --- a/pkg/agent/pipeline_finalize.go +++ b/pkg/agent/pipeline_finalize.go @@ -6,6 +6,7 @@ import ( "context" "github.com/sipeed/picoclaw/pkg/bus" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/providers" ) @@ -50,7 +51,7 @@ func (p *Pipeline) Finalize( ts.ingestMessage(turnCtx, al, finalMsg) if err := ts.agent.Sessions.Save(ts.sessionKey); err != nil { al.emitEvent( - EventKindError, + runtimeevents.KindAgentError, ts.eventMeta("runTurn", "turn.error"), ErrorPayload{ Stage: "session_save", diff --git a/pkg/agent/pipeline_llm.go b/pkg/agent/pipeline_llm.go index a954c0ca6..afec9a486 100644 --- a/pkg/agent/pipeline_llm.go +++ b/pkg/agent/pipeline_llm.go @@ -12,6 +12,7 @@ import ( "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/constants" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" ) @@ -114,7 +115,7 @@ func (p *Pipeline) CallLLM( } al.emitEvent( - EventKindLLMRequest, + runtimeevents.KindAgentLLMRequest, ts.eventMeta("runTurn", "turn.llm.request"), LLMRequestPayload{ Model: exec.llmModel, @@ -200,7 +201,7 @@ func (p *Pipeline) CallLLM( // Retry without media if vision is unsupported if hasMediaRefs(exec.callMessages) && isVisionUnsupportedError(err) && retry < maxRetries { al.emitEvent( - EventKindLLMRetry, + runtimeevents.KindAgentLLMRetry, ts.eventMeta("runTurn", "turn.llm.retry"), LLMRetryPayload{ Attempt: retry + 1, @@ -247,7 +248,7 @@ func (p *Pipeline) CallLLM( if isTimeoutError && retry < maxRetries { backoff := time.Duration(retry+1) * 5 * time.Second al.emitEvent( - EventKindLLMRetry, + runtimeevents.KindAgentLLMRetry, ts.eventMeta("runTurn", "turn.llm.retry"), LLMRetryPayload{ Attempt: retry + 1, @@ -275,7 +276,7 @@ func (p *Pipeline) CallLLM( if isContextError && retry < maxRetries && !ts.opts.NoHistory { al.emitEvent( - EventKindLLMRetry, + runtimeevents.KindAgentLLMRetry, ts.eventMeta("runTurn", "turn.llm.retry"), LLMRetryPayload{ Attempt: retry + 1, @@ -334,7 +335,7 @@ func (p *Pipeline) CallLLM( if err != nil { al.emitEvent( - EventKindError, + runtimeevents.KindAgentError, ts.eventMeta("runTurn", "turn.error"), ErrorPayload{ Stage: "llm", @@ -394,7 +395,7 @@ func (p *Pipeline) CallLLM( ) } al.emitEvent( - EventKindLLMResponse, + runtimeevents.KindAgentLLMResponse, ts.eventMeta("runTurn", "turn.llm.response"), LLMResponsePayload{ ContentLen: len(exec.response.Content), diff --git a/pkg/agent/steering.go b/pkg/agent/steering.go index 2efa7bbf4..ba171fe5d 100644 --- a/pkg/agent/steering.go +++ b/pkg/agent/steering.go @@ -8,6 +8,7 @@ import ( "sync" "github.com/sipeed/picoclaw/pkg/bus" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/session" @@ -206,7 +207,7 @@ func (al *AgentLoop) enqueueSteeringMessage(scope, agentID string, msg providers "scope": normalizeSteeringScope(scope), }) - meta := EventMeta{ + meta := HookMeta{ Source: "Steer", TracePath: "turn.interrupt.received", } @@ -230,7 +231,7 @@ func (al *AgentLoop) enqueueSteeringMessage(scope, agentID string, msg providers } al.emitEvent( - EventKindInterruptReceived, + runtimeevents.KindAgentInterruptReceived, meta, InterruptReceivedPayload{ Kind: InterruptKindSteering, @@ -410,7 +411,7 @@ func (al *AgentLoop) InterruptGraceful(hint string) error { } al.emitEvent( - EventKindInterruptReceived, + runtimeevents.KindAgentInterruptReceived, ts.eventMeta("InterruptGraceful", "turn.interrupt.received"), InterruptReceivedPayload{ Kind: InterruptKindGraceful, @@ -438,7 +439,7 @@ func (al *AgentLoop) InterruptHard() error { } al.emitEvent( - EventKindInterruptReceived, + runtimeevents.KindAgentInterruptReceived, ts.eventMeta("InterruptHard", "turn.interrupt.received"), InterruptReceivedPayload{ Kind: InterruptKindHard, diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go index 4d824bd3a..62ea0e7e7 100644 --- a/pkg/agent/subturn.go +++ b/pkg/agent/subturn.go @@ -8,6 +8,7 @@ import ( "sync/atomic" "time" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" "github.com/sipeed/picoclaw/pkg/providers/messageutil" @@ -422,7 +423,7 @@ func spawnSubTurn( parentTS.mu.Unlock() // 6. Emit Spawn event - al.emitEvent(EventKindSubTurnSpawn, + al.emitEvent(runtimeevents.KindAgentSubTurnSpawn, childTS.eventMeta("spawnSubTurn", "subturn.spawn"), SubTurnSpawnPayload{ AgentID: childTS.agentID, @@ -453,7 +454,7 @@ func spawnSubTurn( if err != nil { status = "error" } - al.emitEvent(EventKindSubTurnEnd, + al.emitEvent(runtimeevents.KindAgentSubTurnEnd, childTS.eventMeta("spawnSubTurn", "subturn.end"), SubTurnEndPayload{ AgentID: childTS.agentID, @@ -526,7 +527,7 @@ func deliverSubTurnResult(al *AgentLoop, parentTS *turnState, childID string, re "recover": r, }) if result != nil && al != nil { - al.emitEvent(EventKindSubTurnOrphan, + al.emitEvent(runtimeevents.KindAgentSubTurnOrphan, parentTS.eventMeta("deliverSubTurnResult", "subturn.orphan"), SubTurnOrphanPayload{ParentTurnID: parentTS.turnID, ChildTurnID: childID, Reason: "panic"}, ) @@ -541,7 +542,7 @@ func deliverSubTurnResult(al *AgentLoop, parentTS *turnState, childID string, re // If parent turn has already finished, treat this as an orphan result if isFinished || resultChan == nil { if result != nil && al != nil { - al.emitEvent(EventKindSubTurnOrphan, + al.emitEvent(runtimeevents.KindAgentSubTurnOrphan, parentTS.eventMeta("deliverSubTurnResult", "subturn.orphan"), SubTurnOrphanPayload{ParentTurnID: parentTS.turnID, ChildTurnID: childID, Reason: "parent_finished"}, ) @@ -557,7 +558,7 @@ func deliverSubTurnResult(al *AgentLoop, parentTS *turnState, childID string, re case resultChan <- result: // Successfully delivered if al != nil { - al.emitEvent(EventKindSubTurnResultDelivered, + al.emitEvent(runtimeevents.KindAgentSubTurnResultDelivered, parentTS.eventMeta("deliverSubTurnResult", "subturn.result_delivered"), SubTurnResultDeliveredPayload{ContentLen: len(result.ForLLM)}, ) @@ -571,7 +572,7 @@ func deliverSubTurnResult(al *AgentLoop, parentTS *turnState, childID string, re }) if result != nil && al != nil { al.emitEvent( - EventKindSubTurnOrphan, + runtimeevents.KindAgentSubTurnOrphan, parentTS.eventMeta("deliverSubTurnResult", "subturn.orphan"), SubTurnOrphanPayload{ ParentTurnID: parentTS.turnID, diff --git a/pkg/agent/turn_context.go b/pkg/agent/turn_context.go index 8913993aa..c675590ce 100644 --- a/pkg/agent/turn_context.go +++ b/pkg/agent/turn_context.go @@ -61,7 +61,7 @@ func cloneStringMap(src map[string]string) map[string]string { return cloned } -func cloneEventMeta(meta EventMeta) EventMeta { +func cloneHookMeta(meta HookMeta) HookMeta { meta.turnContext = cloneTurnContext(meta.turnContext) return meta } diff --git a/pkg/agent/turn_coord.go b/pkg/agent/turn_coord.go index ade2b7c21..ae6bd8c82 100644 --- a/pkg/agent/turn_coord.go +++ b/pkg/agent/turn_coord.go @@ -9,6 +9,7 @@ import ( "time" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" "github.com/sipeed/picoclaw/pkg/logger" "github.com/sipeed/picoclaw/pkg/providers" ) @@ -28,7 +29,7 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState, pipeline *Pipel turnStatus := TurnEndStatusCompleted defer func() { al.emitEvent( - EventKindTurnEnd, + runtimeevents.KindAgentTurnEnd, ts.eventMeta("runTurn", "turn.end"), TurnEndPayload{ Status: turnStatus, @@ -40,7 +41,7 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState, pipeline *Pipel }() al.emitEvent( - EventKindTurnStart, + runtimeevents.KindAgentTurnStart, ts.eventMeta("runTurn", "turn.start"), TurnStartPayload{ UserMessage: ts.userMessage, @@ -140,7 +141,7 @@ func (al *AgentLoop) runTurn(ctx context.Context, ts *turnState, pipeline *Pipel }) } al.emitEvent( - EventKindSteeringInjected, + runtimeevents.KindAgentSteeringInjected, ts.eventMeta("runTurn", "turn.steering.injected"), SteeringInjectedPayload{ Count: len(pendingMessages), @@ -249,7 +250,7 @@ func (al *AgentLoop) abortTurn(ts *turnState) (turnResult, error) { if !ts.opts.NoHistory { if err := ts.restoreSession(ts.agent); err != nil { al.emitEvent( - EventKindError, + runtimeevents.KindAgentError, ts.eventMeta("abortTurn", "turn.error"), ErrorPayload{ Stage: "session_restore", @@ -414,7 +415,7 @@ func (al *AgentLoop) askSideQuestion( llmModel := activeModel if al.hooks != nil { llmReq, decision := al.hooks.BeforeLLM(ctx, &LLMHookRequest{ - Meta: EventMeta{ + Meta: HookMeta{ Source: "askSideQuestion", TracePath: "turn.llm.request", turnContext: cloneTurnContext(turnCtx), @@ -494,8 +495,8 @@ func (al *AgentLoop) askSideQuestion( resp, err = callSideLLM(messages) if err != nil && hasMediaRefs(messages) && isVisionUnsupportedError(err) { al.emitEvent( - EventKindLLMRetry, - EventMeta{ + runtimeevents.KindAgentLLMRetry, + HookMeta{ Source: "askSideQuestion", TracePath: "turn.llm.retry", turnContext: cloneTurnContext(turnCtx), @@ -521,7 +522,7 @@ func (al *AgentLoop) askSideQuestion( // Apply after_llm hooks if al.hooks != nil { llmResp, decision := al.hooks.AfterLLM(ctx, &LLMHookResponse{ - Meta: EventMeta{ + Meta: HookMeta{ Source: "askSideQuestion", TracePath: "turn.llm.response", turnContext: cloneTurnContext(turnCtx), diff --git a/pkg/agent/turn_state.go b/pkg/agent/turn_state.go index 360c3b7d5..85e7dd3c0 100644 --- a/pkg/agent/turn_state.go +++ b/pkg/agent/turn_state.go @@ -442,9 +442,9 @@ func (ts *turnState) hardAbortRequested() bool { return ts.hardAbort } -func (ts *turnState) eventMeta(source, tracePath string) EventMeta { +func (ts *turnState) eventMeta(source, tracePath string) HookMeta { snap := ts.snapshot() - return EventMeta{ + return HookMeta{ AgentID: snap.AgentID, TurnID: snap.TurnID, SessionKey: snap.SessionKey, From e613258fa5655a2c5d9eb75cd1006005dc7cdcee Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 17:02:48 +0800 Subject: [PATCH 22/53] feat(gateway): publish lifecycle runtime events Emit gateway.start, gateway.ready, and gateway.shutdown on the shared runtime event bus, while keeping reload events on the same helper path. Update subturn architecture docs to refer to runtime event kinds instead of the removed agent EventBus names. Validation: GOCACHE=/tmp/picoclaw-go-cache go test ./pkg/gateway ./pkg/events; GOCACHE=/tmp/picoclaw-go-cache go test ./pkg/bus ./pkg/channels ./pkg/mcp ./pkg/tools/integration ./pkg/events ./pkg/gateway; make lint --- docs/architecture/subturn.md | 16 ++++----- pkg/events/kind.go | 6 ++++ pkg/gateway/events.go | 6 ++-- pkg/gateway/gateway.go | 11 ++++-- pkg/gateway/gateway_test.go | 66 ++++++++++++++++++++++++++++++++++++ 5 files changed, 91 insertions(+), 14 deletions(-) diff --git a/docs/architecture/subturn.md b/docs/architecture/subturn.md index 0a927b56d..31a56902c 100644 --- a/docs/architecture/subturn.md +++ b/docs/architecture/subturn.md @@ -135,16 +135,16 @@ The agent loop polls for async SubTurn results at two points per iteration: All active turns are registered in `AgentLoop.activeTurnStates` (`sync.Map`, keyed by session key). A reservation sentinel is stored atomically via `LoadOrStore` before the worker starts, then replaced with the real `*turnState` when `runTurn` registers. This prevents a TOCTOU race where multiple messages for the same session could spawn concurrent workers. The sentinel is cleaned up by the worker's deferred cleanup. This allows `HardAbort` and `/subagents` observability commands to find and operate on active turns. -## Event Bus Integration +## Runtime Event Integration -SubTurns emit specific events to the PicoClaw `EventBus` for observability and debugging: +SubTurns emit runtime events through `pkg/events` for observability and debugging: | Event Kind | When Emitted | Payload | |:------|:-------------|:--------| -| `subturn_spawn` | Sub-turn successfully initialized | `SubTurnSpawnPayload{AgentID, Label, ParentTurnID}` | -| `subturn_end` | Sub-turn finishes (success or error) | `SubTurnEndPayload{AgentID, Status}` | -| `subturn_result_delivered` | Async result successfully delivered to parent | `SubTurnResultDeliveredPayload{TargetChannel, TargetChatID, ContentLen}` | -| `subturn_orphan` | Result cannot be delivered (parent finished or channel full) | `SubTurnOrphanPayload{ParentTurnID, ChildTurnID, Reason}` | +| `agent.subturn.spawn` | Sub-turn successfully initialized | `SubTurnSpawnPayload{AgentID, Label, ParentTurnID}` | +| `agent.subturn.end` | Sub-turn finishes (success or error) | `SubTurnEndPayload{AgentID, Status}` | +| `agent.subturn.result_delivered` | Async result successfully delivered to parent | `SubTurnResultDeliveredPayload{TargetChannel, TargetChatID, ContentLen}` | +| `agent.subturn.orphan` | Result cannot be delivered (parent finished or channel full) | `SubTurnOrphanPayload{ParentTurnID, ChildTurnID, Reason}` | ## API Reference @@ -240,13 +240,13 @@ An orphan result occurs when: 2. The `pendingResults` channel is full (buffer size: 16) When a result becomes orphan: -- `SubTurnOrphanResultEvent` is emitted to EventBus +- `agent.subturn.orphan` is emitted to the runtime event bus - The result is **NOT** delivered to the LLM context - External systems can listen to this event for custom handling ### Preventing Orphan Results - Use `Critical: true` for important SubTurns that must complete -- Monitor `SubTurnOrphanResultEvent` for observability +- Monitor `agent.subturn.orphan` for observability - Consider the 16-buffer limit when spawning many async SubTurns ## Tool Inheritance diff --git a/pkg/events/kind.go b/pkg/events/kind.go index 9d7319b93..85e61f741 100644 --- a/pkg/events/kind.go +++ b/pkg/events/kind.go @@ -75,6 +75,12 @@ const ( // KindBusCloseDrained is emitted when message bus close drains buffered messages. KindBusCloseDrained Kind = "bus.close.drained" + // KindGatewayStart is emitted when gateway startup reaches runtime bootstrap. + KindGatewayStart Kind = "gateway.start" + // KindGatewayReady is emitted when gateway services are started and ready. + KindGatewayReady Kind = "gateway.ready" + // KindGatewayShutdown is emitted when gateway shutdown starts. + KindGatewayShutdown Kind = "gateway.shutdown" // KindGatewayReloadStarted is emitted when gateway reload starts. KindGatewayReloadStarted Kind = "gateway.reload.started" // KindGatewayReloadCompleted is emitted when gateway reload completes. diff --git a/pkg/gateway/events.go b/pkg/gateway/events.go index d690a4eaf..fd263fba6 100644 --- a/pkg/gateway/events.go +++ b/pkg/gateway/events.go @@ -10,12 +10,12 @@ import ( const gatewayEventPublishTimeout = 100 * time.Millisecond -type gatewayReloadPayload struct { +type gatewayEventPayload struct { DurationMS int64 `json:"duration_ms,omitempty"` Error string `json:"error,omitempty"` } -func publishGatewayReloadEvent( +func publishGatewayEvent( al *agent.AgentLoop, kind runtimeevents.Kind, startedAt time.Time, @@ -26,7 +26,7 @@ func publishGatewayReloadEvent( } severity := runtimeevents.SeverityInfo - payload := gatewayReloadPayload{} + payload := gatewayEventPayload{} if !startedAt.IsZero() { payload.DurationMS = time.Since(startedAt).Milliseconds() } diff --git a/pkg/gateway/gateway.go b/pkg/gateway/gateway.go index 01b6f7d5e..dd579ed7e 100644 --- a/pkg/gateway/gateway.go +++ b/pkg/gateway/gateway.go @@ -115,6 +115,7 @@ func (p *startupBlockedProvider) GetDefaultModel() string { // Run starts the gateway runtime using the configuration loaded from configPath. func Run(debug bool, homePath, configPath string, allowEmptyStartup bool) (runErr error) { + startedAt := time.Now() panicPath := filepath.Join(homePath, logPath, panicFile) panicFunc, err := logger.InitPanic(panicPath) if err != nil { @@ -199,6 +200,7 @@ func Run(debug bool, homePath, configPath string, allowEmptyStartup bool) (runEr msgBus := bus.NewMessageBus() agentLoop := agent.NewAgentLoop(cfg, msgBus, provider) msgBus.SetEventPublisher(agentLoop.RuntimeEventBus()) + publishGatewayEvent(agentLoop, runtimeevents.KindGatewayStart, startedAt, nil) fmt.Println("\n📦 Agent Status:") startupInfo := agentLoop.GetStartupInfo() @@ -218,6 +220,7 @@ func Run(debug bool, homePath, configPath string, allowEmptyStartup bool) (runEr if err != nil { return err } + publishGatewayEvent(agentLoop, runtimeevents.KindGatewayReady, startedAt, nil) closeListeners = false // Setup manual reload channel for /reload endpoint @@ -316,14 +319,14 @@ func executeReload( debug bool, ) (err error) { startedAt := time.Now() - publishGatewayReloadEvent(agentLoop, runtimeevents.KindGatewayReloadStarted, startedAt, nil) + publishGatewayEvent(agentLoop, runtimeevents.KindGatewayReloadStarted, startedAt, nil) defer runningServices.reloading.Store(false) defer func() { if err != nil { - publishGatewayReloadEvent(agentLoop, runtimeevents.KindGatewayReloadFailed, startedAt, err) + publishGatewayEvent(agentLoop, runtimeevents.KindGatewayReloadFailed, startedAt, err) return } - publishGatewayReloadEvent(agentLoop, runtimeevents.KindGatewayReloadCompleted, startedAt, nil) + publishGatewayEvent(agentLoop, runtimeevents.KindGatewayReloadCompleted, startedAt, nil) }() err = handleConfigReload(ctx, agentLoop, newCfg, provider, runningServices, msgBus, allowEmptyStartup, debug) @@ -509,6 +512,8 @@ func shutdownGateway( provider providers.LLMProvider, fullShutdown bool, ) { + publishGatewayEvent(agentLoop, runtimeevents.KindGatewayShutdown, time.Time{}, nil) + if cp, ok := provider.(providers.StatefulProvider); ok && fullShutdown { cp.Close() } diff --git a/pkg/gateway/gateway_test.go b/pkg/gateway/gateway_test.go index 60049337f..9af833b6b 100644 --- a/pkg/gateway/gateway_test.go +++ b/pkg/gateway/gateway_test.go @@ -1,14 +1,19 @@ package gateway import ( + "context" "fmt" "os" "os/exec" "path/filepath" "strings" "testing" + "time" + "github.com/sipeed/picoclaw/pkg/agent" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) func TestRun_StartupFailuresReturnErrorAndEmitStructuredLog(t *testing.T) { @@ -106,3 +111,64 @@ func TestGatewayRunStartupFailureHelper(t *testing.T) { fmt.Fprintln(os.Stdout, err.Error()) os.Exit(0) } + +func TestPublishGatewayEvent(t *testing.T) { + eventBus := runtimeevents.NewBus() + t.Cleanup(func() { + if err := eventBus.Close(); err != nil { + t.Fatalf("Close runtime event bus: %v", err) + } + }) + + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + sub, eventsCh, err := eventBus.Channel().OfKind(runtimeevents.KindGatewayStart).SubscribeChan( + ctx, + runtimeevents.SubscribeOptions{Name: "gateway-test", Buffer: 4}, + ) + if err != nil { + t.Fatalf("SubscribeChan() error = %v", err) + } + t.Cleanup(func() { + if err := sub.Close(); err != nil { + t.Fatalf("Close subscription: %v", err) + } + }) + + al := agent.NewAgentLoop( + config.DefaultConfig(), + bus.NewMessageBus(), + &startupBlockedProvider{reason: "not used"}, + agent.WithRuntimeEvents(eventBus), + ) + t.Cleanup(al.Close) + + startedAt := time.Now().Add(-1500 * time.Millisecond) + publishGatewayEvent(al, runtimeevents.KindGatewayStart, startedAt, nil) + + evt := receiveGatewayRuntimeEvent(t, eventsCh) + if evt.Kind != runtimeevents.KindGatewayStart || + evt.Source.Component != "gateway" || + evt.Severity != runtimeevents.SeverityInfo { + t.Fatalf("gateway event = %+v", evt) + } + payload, ok := evt.Payload.(gatewayEventPayload) + if !ok { + t.Fatalf("payload type = %T, want gatewayEventPayload", evt.Payload) + } + if payload.DurationMS <= 0 { + t.Fatalf("DurationMS = %d, want positive", payload.DurationMS) + } +} + +func receiveGatewayRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { + t.Helper() + + select { + case evt := <-ch: + return evt + case <-time.After(time.Second): + t.Fatal("timed out waiting for gateway runtime event") + return runtimeevents.Event{} + } +} From f4a24614b88c4a574aaf2983c32a27ea9d605d25 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 17:04:38 +0800 Subject: [PATCH 23/53] docs(events): remove stale subturn event names Replace leftover SubTurnOrphanResultEvent and short subturn event references with runtime event kinds in comments, tests, and hook design notes. Validation: GOCACHE=/tmp/picoclaw-go-cache go test ./pkg/agent -run TestSpawnSubTurn_OrphanResultRouting; make lint --- docs/design/hook-system-design.zh.md | 2 +- pkg/agent/subturn.go | 8 ++++---- pkg/agent/subturn_test.go | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/design/hook-system-design.zh.md b/docs/design/hook-system-design.zh.md index b654112bf..090437c20 100644 --- a/docs/design/hook-system-design.zh.md +++ b/docs/design/hook-system-design.zh.md @@ -455,7 +455,7 @@ V1 不做复杂自动发现。 ### Phase 3 - 把 `SubagentManager` 迁移到 `runTurn/sub-turn` -- 接通 `subturn_spawn` / `subturn_end` / `subturn_result_delivered` +- 接通 `agent.subturn.spawn` / `agent.subturn.end` / `agent.subturn.result_delivered` ### Phase 4 diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go index 62ea0e7e7..483c72842 100644 --- a/pkg/agent/subturn.go +++ b/pkg/agent/subturn.go @@ -505,16 +505,16 @@ func spawnSubTurn( // // Delivery behavior: // - If parent turn is still running: attempts to deliver to pendingResults channel -// - If channel is full: emits SubTurnOrphanResultEvent (result is lost from channel but tracked) -// - If parent turn has finished: emits SubTurnOrphanResultEvent (late arrival) +// - If channel is full: emits agent.subturn.orphan (result is lost from channel but tracked) +// - If parent turn has finished: emits agent.subturn.orphan (late arrival) // // Thread safety: // - Reads parent state under lock, then releases lock before channel send // - Small race window exists but is acceptable (worst case: result becomes orphan) // // Event emissions: -// - SubTurnResultDeliveredEvent: successful delivery to channel -// - SubTurnOrphanResultEvent: delivery failed (parent finished or channel full) +// - agent.subturn.result_delivered: successful delivery to channel +// - agent.subturn.orphan: delivery failed (parent finished or channel full) func deliverSubTurnResult(al *AgentLoop, parentTS *turnState, childID string, result *tools.ToolResult) { // Let GC clean up the pendingResults channel; parent Finish will no longer close it. // We use defer/recover to catch any unlikely channel panics if it were ever closed. diff --git a/pkg/agent/subturn_test.go b/pkg/agent/subturn_test.go index ac4184e7e..6a33892db 100644 --- a/pkg/agent/subturn_test.go +++ b/pkg/agent/subturn_test.go @@ -326,7 +326,7 @@ func TestSpawnSubTurn_OrphanResultRouting(t *testing.T) { time.Sleep(10 * time.Millisecond) // let event goroutine flush // Verify Orphan event is emitted if !collector.hasEventOfKind(runtimeevents.KindAgentSubTurnOrphan) { - t.Error("SubTurnOrphanResultEvent not emitted for finished parent") + t.Error("agent.subturn.orphan not emitted for finished parent") } // Verify history is NOT polluted From b3d9f86a01e634cc0afa5b6d95520ac01dd29fc4 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 17:41:00 +0800 Subject: [PATCH 24/53] feat(events): add configurable runtime event logging --- config/config.example.json | 9 + docs/architecture/README.md | 1 + docs/architecture/runtime-events.md | 216 +++++++++++++++++ docs/architecture/runtime-events.zh.md | 216 +++++++++++++++++ docs/guides/configuration.zh.md | 37 +++ pkg/agent/agent.go | 10 +- pkg/agent/agent_event.go | 100 -------- pkg/agent/agent_init.go | 1 + pkg/agent/runtime_event_logger.go | 316 +++++++++++++++++++++++++ pkg/agent/runtime_event_logger_test.go | 99 ++++++++ pkg/config/config.go | 1 + pkg/config/defaults.go | 3 + pkg/config/events.go | 48 ++++ pkg/config/events_test.go | 103 ++++++++ 14 files changed, 1057 insertions(+), 103 deletions(-) create mode 100644 docs/architecture/runtime-events.md create mode 100644 docs/architecture/runtime-events.zh.md create mode 100644 pkg/agent/runtime_event_logger.go create mode 100644 pkg/agent/runtime_event_logger_test.go create mode 100644 pkg/config/events.go create mode 100644 pkg/config/events_test.go diff --git a/config/config.example.json b/config/config.example.json index 30460c231..a90d78e24 100644 --- a/config/config.example.json +++ b/config/config.example.json @@ -476,6 +476,15 @@ "approval_timeout_ms": 60000 } }, + "events": { + "logging": { + "enabled": true, + "include": ["agent.*"], + "exclude": [], + "min_severity": "info", + "include_payload": false + } + }, "gateway": { "_comment": "Default log level is set to 'fatal'. Other available options are 'debug', 'info', 'warn' and 'error'.", "host": "localhost", diff --git a/docs/architecture/README.md b/docs/architecture/README.md index 6df7447a7..e5fc3b540 100644 --- a/docs/architecture/README.md +++ b/docs/architecture/README.md @@ -6,6 +6,7 @@ Internal architecture notes for major runtime mechanisms and subsystem design. - [SubTurn Mechanism](subturn.md): sub-agent coordination, concurrency control, and lifecycle handling. - [Session System](session-system.md): session scope allocation, JSONL persistence, alias compatibility, and migration. ([ZH](session-system.zh.md)) - [Routing System](routing-system.md): agent dispatch, session policy selection, and light/heavy model routing. ([ZH](routing-system.zh.md)) +- [Runtime Events](runtime-events.md): runtime event envelope, centralized event logging, filters, and examples. ([ZH](runtime-events.zh.md)) - [Hook System Guide](hooks/README.md): current hook architecture and protocol details. - [Agent Refactor](agent-refactor/README.md): notes and checkpoints for the agent refactor work. diff --git a/docs/architecture/runtime-events.md b/docs/architecture/runtime-events.md new file mode 100644 index 000000000..5d625a34b --- /dev/null +++ b/docs/architecture/runtime-events.md @@ -0,0 +1,216 @@ +# Runtime Events And Event Logging + +PicoClaw runtime events are the read-only observation surface for agent, channel, gateway, message bus, and MCP activity. Publishing events and printing logs are separate responsibilities: + +- Event publishing: components publish `pkg/events.Event` values to the runtime event bus for hooks, tests, diagnostics, and future UI consumers. +- Event logging: the built-in runtime event logger subscribes to the same bus and prints only the events selected by configuration. + +This keeps runtime code focused on publishing events while log policy stays centralized. + +## Default Behavior + +By default, only `agent.*` events are printed: + +```json +{ + "events": { + "logging": { + "enabled": true, + "include": ["agent.*"], + "min_severity": "info", + "include_payload": false + } + } +} +``` + +This preserves the previous behavior: agent turn, LLM, tool, steering, subturn, and error events appear in logs. Channel, gateway, bus, and MCP events are still published to the runtime event bus, but they are not printed unless configured. + +## Configuration + +The configuration lives under `events.logging` in `config.json`: + +| Field | Type | Default | Description | +| ----- | ---- | ------- | ----------- | +| `enabled` | bool | `true` | Enables the built-in event logger subscription | +| `include` | string[] | `["agent.*"]` | Event kinds to print; supports exact matches, `*`, and patterns such as `agent.*` | +| `exclude` | string[] | `[]` | Event kinds to suppress after include matching | +| `min_severity` | string | `info` | Minimum severity: `debug`, `info`, `warn`, or `error` | +| `include_payload` | bool | `false` | Adds raw event payloads to log fields | + +`include_payload` is disabled by default. Agent events print safe summary fields such as `user_len`, `args_count`, and `content_len` instead of full user messages or tool arguments. Enable raw payload logging only for short-lived diagnostics in a trusted log environment. + +## Matching Rules + +`include` and `exclude` match the `Event.Kind` string: + +```json +{ + "events": { + "logging": { + "include": ["gateway.*", "channel.lifecycle.*", "agent.error"], + "exclude": ["gateway.ready"], + "min_severity": "info" + } + } +} +``` + +Common patterns: + +- `["agent.*"]`: print agent events only. +- `["*"]`: print all runtime events. +- `["gateway.*", "channel.*"]`: print gateway and channel events only. +- `exclude: ["agent.llm.delta"]`: suppress high-volume streaming delta events. +- `min_severity: "warn"`: print warn and error events only. + +## Environment Variables + +The same settings can be overridden with environment variables: + +```bash +PICOCLAW_EVENTS_LOGGING_ENABLED=true +PICOCLAW_EVENTS_LOGGING_INCLUDE="gateway.*,channel.lifecycle.*" +PICOCLAW_EVENTS_LOGGING_EXCLUDE="gateway.ready" +PICOCLAW_EVENTS_LOGGING_MIN_SEVERITY=info +PICOCLAW_EVENTS_LOGGING_INCLUDE_PAYLOAD=false +``` + +`include` and `exclude` use comma-separated values. + +## Event Names And Triggers + +The table below lists the current runtime event kinds, when they are emitted, and the most useful event details. `Source`, `Scope`, and `Correlation` are shared envelope fields that may appear on every event. The "Details" column refers to useful payload fields or log summary fields. + +### Agent + +| Event | Trigger | Details | +| ----- | ------- | ------- | +| `agent.turn.start` | An agent starts processing one user or system input after the turn scope has been created. | `user_len`, `media_count`; scope usually includes `agent_id`, `session_key`, `turn_id`, `channel`, `chat_id`, `message_id` | +| `agent.turn.end` | A turn exits, whether it completed, errored, or was hard-aborted. | `status` (`completed`/`error`/`aborted`), `iterations_total`, `duration_ms`, `final_len` | +| `agent.llm.request` | Before each LLM provider request. | `model`, `messages`, `tools`, `max_tokens` | +| `agent.llm.delta` | Reserved for streaming LLM deltas; the kind is defined, but the current implementation has no natural emit site. | `content_delta_len`, `reasoning_delta_len` | +| `agent.llm.response` | After the LLM provider returns a complete response. | `content_len`, `tool_calls`, `has_reasoning` | +| `agent.llm.retry` | Before retrying an LLM request after context, rate-limit, transient provider, or fallback handling. | `attempt`, `max_retries`, `reason`, `error`, `backoff_ms` | +| `agent.context.compress` | Agent context history is compressed, for example during proactive budget checks or LLM retry handling. | `reason`, `dropped_messages`, `remaining_messages` | +| `agent.session.summarize` | Async session history summarization completes. | `summarized_messages`, `kept_messages`, `summary_len`, `omitted_oversized` | +| `agent.tool.exec_start` | Before the agent executes a tool call. | `tool`, `args_count`; full arguments are not logged by default | +| `agent.tool.exec_end` | After a tool call completes, including successful results, tool errors, and async results. | `tool`, `duration_ms`, `for_llm_len`, `for_user_len`, `is_error`, `async` | +| `agent.tool.exec_skipped` | A tool call is skipped because the tool is unavailable, arguments are invalid, or turn control logic requires skipping it. | `tool`, `reason` | +| `agent.steering.injected` | Queued steering messages are injected into the next LLM context. | `count`, `total_content_len` | +| `agent.follow_up.queued` | An async tool result is queued back into the inbound/follow-up flow. | `source_tool`, `content_len` | +| `agent.interrupt.received` | A turn accepts steering, graceful interrupt, or hard-abort input. | `interrupt_kind`, `role`, `content_len`, `queue_depth`, `hint_len` | +| `agent.subturn.spawn` | A parent turn creates a child turn/subagent. | `child_agent_id`, `label`, `parent_turn_id` | +| `agent.subturn.end` | A child turn ends. | `child_agent_id`, `status` | +| `agent.subturn.result_delivered` | A child turn result is delivered to the target channel/chat. | `target_channel`, `target_chat_id`, `content_len` | +| `agent.subturn.orphan` | A child turn result cannot be delivered or cannot be associated back to its parent turn. | `parent_turn_id`, `child_turn_id`, `reason` | +| `agent.error` | Agent execution reports an error. | `stage`, `error` | + +### Channel + +| Event | Trigger | Details | +| ----- | ------- | ------- | +| `channel.lifecycle.initialized` | The channel manager creates and registers a channel instance from config. | `type`; scope includes `channel` | +| `channel.lifecycle.started` | Channel `Start()` succeeds and worker goroutines have been started; added channels during hot reload also emit it. | `type` | +| `channel.lifecycle.start_failed` | Channel `Start()` fails. | `type`, `error`; severity is `error` | +| `channel.lifecycle.stopped` | Channel `Stop()` succeeds. | `type` | +| `channel.webhook.registered` | A channel webhook handler is registered on the shared HTTP mux. | `type`; scope includes `channel` | +| `channel.webhook.unregistered` | A channel webhook handler is removed from the shared HTTP mux. | `type`; scope includes `channel` | +| `channel.message.outbound_queued` | An outbound text or media message is queued into its channel worker. | `media`, `content_len`, `reply_to_message_id`; scope comes from the original inbound context | +| `channel.message.outbound_sent` | An outbound text or media message is sent successfully, or a placeholder edit handled the response. | `media`, `content_len`, `message_ids`, `reply_to_message_id` | +| `channel.message.outbound_failed` | An outbound text or media message exhausts retries or hits a permanent failure. | `media`, `content_len`, `retries`, `error`, `reply_to_message_id`; severity is `error` | +| `channel.rate_limited` | A channel worker is waiting for a rate-limit token and the context is canceled, interrupting this delivery. | `media`, `content_len`, `error`, `reply_to_message_id`; severity is `warn` | + +### Message Bus + +| Event | Trigger | Details | +| ----- | ------- | ------- | +| `bus.publish.failed` | Publishing inbound, outbound, media, audio, or voice-control data fails, or required context is missing. | `stream`, `error`; scope is derived from message context when possible | +| `bus.close.started` | Message bus shutdown begins. | `drained` is usually `0` | +| `bus.close.drained` | Shutdown waits for buffered messages to drain and at least one buffered message was drained. | `drained` | +| `bus.close.completed` | Message bus shutdown completes. | `drained` | + +### Gateway + +| Event | Trigger | Details | +| ----- | ------- | ------- | +| `gateway.start` | Gateway startup reaches the agent/runtime event bus/bootstrap binding point. | `duration_ms` | +| `gateway.ready` | Gateway services, channel manager, HTTP server, and other core services are ready. | `duration_ms` | +| `gateway.shutdown` | Gateway shutdown begins. | No fixed payload; envelope fields may be the only fields | +| `gateway.reload.started` | Hot reload execution starts. | `duration_ms` | +| `gateway.reload.completed` | Hot reload completes successfully. | `duration_ms` | +| `gateway.reload.failed` | Hot reload fails. | `duration_ms`, `error`; severity is `error` | + +### MCP + +| Event | Trigger | Details | +| ----- | ------- | ------- | +| `mcp.server.connecting` | The MCP manager is about to connect to a server. | `server`, `type`, `url`, `command` | +| `mcp.server.connected` | An MCP server connects and its tool list has been initialized. | `server`, `type`, `url`, `command`, `tool_count` | +| `mcp.server.failed` | An MCP server connection fails, or the manager is closed before connecting. | `server`, `type`, `url`, `command`, `error`; severity is `error` | +| `mcp.tool.discovered` | A tool from an MCP server is discovered and registered. | `server`, `type`, `url`, `command`, `tool` | +| `mcp.tool.call.start` | The MCP tool wrapper starts a remote tool call. | `server`, `tool`; when emitted inside an agent turn, scope includes turn/chat information | +| `mcp.tool.call.end` | The MCP tool wrapper finishes a remote tool call, including failures. | `server`, `tool`, `duration_ms`, `is_error`, `error` | + +## Log Fields + +Runtime event logs include stable envelope fields when available: + +- `event_id` +- `event_kind` +- `severity` +- `event_time` +- `source_component` +- `source_name` +- `agent_id` +- `session_key` +- `turn_id` +- `channel` +- `account` +- `chat_id` +- `topic_id` +- `space_id` +- `space_type` +- `chat_type` +- `sender_id` +- `message_id` +- `trace_id` +- `parent_turn_id` +- `request_id` +- `reply_to_id` + +Agent events add safe payload summaries: + +| Event | Summary fields | +| ----- | -------------- | +| `agent.turn.start` | `user_len`, `media_count` | +| `agent.turn.end` | `status`, `iterations_total`, `duration_ms`, `final_len` | +| `agent.llm.request` | `model`, `messages`, `tools`, `max_tokens` | +| `agent.llm.delta` | `content_delta_len`, `reasoning_delta_len` | +| `agent.llm.response` | `content_len`, `tool_calls`, `has_reasoning` | +| `agent.llm.retry` | `attempt`, `max_retries`, `reason`, `error`, `backoff_ms` | +| `agent.context.compress` | `reason`, `dropped_messages`, `remaining_messages` | +| `agent.session.summarize` | `summarized_messages`, `kept_messages`, `summary_len`, `omitted_oversized` | +| `agent.tool.exec_start` | `tool`, `args_count` | +| `agent.tool.exec_end` | `tool`, `duration_ms`, `for_llm_len`, `for_user_len`, `is_error`, `async` | +| `agent.tool.exec_skipped` | `tool`, `reason` | +| `agent.steering.injected` | `count`, `total_content_len` | +| `agent.follow_up.queued` | `source_tool`, `content_len` | +| `agent.interrupt.received` | `interrupt_kind`, `role`, `content_len`, `queue_depth`, `hint_len` | +| `agent.subturn.spawn` | `child_agent_id`, `label` | +| `agent.subturn.end` | `child_agent_id`, `status` | +| `agent.subturn.result_delivered` | `target_channel`, `target_chat_id`, `content_len` | +| `agent.subturn.orphan` | `parent_turn_id`, `child_turn_id`, `reason` | +| `agent.error` | `stage`, `error` | + +## Event Domains + +Runtime event kinds are defined in `pkg/events/kind.go`. Event logging can select these domains: + +- `agent.*`: agent turn, LLM, tool, context, steering, interrupt, subturn, and error events. +- `channel.*`: channel lifecycle, webhook registration, outbound queued/sent/failed, and rate limiting. +- `bus.*`: publish failures and close lifecycle. +- `gateway.*`: start, ready, shutdown, and reload lifecycle. +- `mcp.*`: MCP server connection, tool discovery, and tool call events. + +See [`../../config/config.example.json`](../../config/config.example.json) for the default event logging example. diff --git a/docs/architecture/runtime-events.zh.md b/docs/architecture/runtime-events.zh.md new file mode 100644 index 000000000..3ed384537 --- /dev/null +++ b/docs/architecture/runtime-events.zh.md @@ -0,0 +1,216 @@ +# Runtime Events 与事件日志 + +PicoClaw 的 runtime event 是运行时观察面，用来描述 agent、channel、gateway、message bus、MCP 等组件发生了什么。事件发布和日志打印是两件事： + +- 事件发布：组件把 `pkg/events.Event` 发布到 runtime event bus，供 hook、测试、调试工具或后续 UI 消费。 +- 事件日志：内置 runtime event logger 订阅同一个 bus，并按配置把匹配的事件打印到日志。 + +这样可以让业务流程继续只负责发布事件，日志策略统一收口到一个地方。 + +## 默认行为 + +默认配置只打印 `agent.*` 事件： + +```json +{ + "events": { + "logging": { + "enabled": true, + "include": ["agent.*"], + "min_severity": "info", + "include_payload": false + } + } +} +``` + +这个默认值保持了旧行为：agent turn、LLM、tool、steering、subturn、error 等事件会出现在日志中；channel、gateway、bus、MCP 事件仍会发布到 runtime event bus，但默认不打印，避免网关启动和消息投递日志过于嘈杂。 + +## 配置项 + +配置位于 `config.json` 的 `events.logging`： + +| 字段 | 类型 | 默认值 | 说明 | +| ---- | ---- | ------ | ---- | +| `enabled` | bool | `true` | 是否启用内置事件日志订阅器 | +| `include` | string[] | `["agent.*"]` | 允许打印的事件 kind，支持精确匹配、`*`、`agent.*` 这类 glob/prefix | +| `exclude` | string[] | `[]` | 在 include 命中后排除的事件 kind，匹配规则同 include | +| `min_severity` | string | `info` | 最低打印级别：`debug`、`info`、`warn`、`error` | +| `include_payload` | bool | `false` | 是否把原始 payload 放进日志字段 | + +`include_payload` 默认关闭。agent 事件日志会输出安全摘要字段，例如 `user_len`、`args_count`、`content_len`，不会默认输出完整用户消息或工具参数。只有在排查问题、并且确认日志存储环境可信时，才建议临时打开 `include_payload`。 + +## 匹配规则 + +`include` 和 `exclude` 都匹配 `Event.Kind` 字符串： + +```json +{ + "events": { + "logging": { + "include": ["gateway.*", "channel.lifecycle.*", "agent.error"], + "exclude": ["gateway.ready"], + "min_severity": "info" + } + } +} +``` + +常用写法： + +- `["agent.*"]`：只打印 agent 事件。 +- `["*"]`：打印所有 runtime events。 +- `["gateway.*", "channel.*"]`：只打印 gateway 和 channel 事件。 +- `exclude: ["agent.llm.delta"]`：排除高频流式 delta 事件。 +- `min_severity: "warn"`：只打印 warn/error 事件。 + +## 环境变量 + +同一组配置也可以通过环境变量覆盖，适合临时调试： + +```bash +PICOCLAW_EVENTS_LOGGING_ENABLED=true +PICOCLAW_EVENTS_LOGGING_INCLUDE="gateway.*,channel.lifecycle.*" +PICOCLAW_EVENTS_LOGGING_EXCLUDE="gateway.ready" +PICOCLAW_EVENTS_LOGGING_MIN_SEVERITY=info +PICOCLAW_EVENTS_LOGGING_INCLUDE_PAYLOAD=false +``` + +`include` 和 `exclude` 的环境变量使用逗号分隔。 + +## 事件名称与触发时机 + +下面列出当前 runtime event kind、触发时机和主要事件详情。`Source`、`Scope`、`Correlation` 是所有事件都可能携带的 envelope 字段；表里的“主要详情”指 payload 或日志摘要中最有用的字段。 + +### Agent + +| 事件名 | 触发时机 | 主要详情 | +| ------ | -------- | -------- | +| `agent.turn.start` | agent 开始处理一次用户输入或系统输入，turn scope 已创建时 | `user_len`, `media_count`; scope 通常包含 `agent_id`, `session_key`, `turn_id`, `channel`, `chat_id`, `message_id` | +| `agent.turn.end` | 一次 turn 退出时，无论完成、报错还是 hard abort | `status` (`completed`/`error`/`aborted`), `iterations_total`, `duration_ms`, `final_len` | +| `agent.llm.request` | 每次调用 LLM provider 前 | `model`, `messages`, `tools`, `max_tokens` | +| `agent.llm.delta` | 预留给流式 LLM delta；当前实现已定义但没有自然发送点 | `content_delta_len`, `reasoning_delta_len` | +| `agent.llm.response` | LLM provider 返回完整响应后 | `content_len`, `tool_calls`, `has_reasoning` | +| `agent.llm.retry` | LLM 请求因上下文、限流、临时错误等原因准备重试前 | `attempt`, `max_retries`, `reason`, `error`, `backoff_ms` | +| `agent.context.compress` | 上下文历史被压缩时，例如主动预算检查或 LLM retry 处理 | `reason`, `dropped_messages`, `remaining_messages` | +| `agent.session.summarize` | 会话历史异步摘要完成时 | `summarized_messages`, `kept_messages`, `summary_len`, `omitted_oversized` | +| `agent.tool.exec_start` | agent 准备执行一个工具调用前 | `tool`, `args_count`; 默认不打印完整参数 | +| `agent.tool.exec_end` | 工具调用完成后，包括成功、工具错误和 async 结果 | `tool`, `duration_ms`, `for_llm_len`, `for_user_len`, `is_error`, `async` | +| `agent.tool.exec_skipped` | 工具调用被跳过时，例如工具不可用、参数无效或 turn 控制逻辑要求跳过 | `tool`, `reason` | +| `agent.steering.injected` | queued steering message 被注入下一轮 LLM 上下文时 | `count`, `total_content_len` | +| `agent.follow_up.queued` | async 工具结果被重新排入 inbound/follow-up 流程时 | `source_tool`, `content_len` | +| `agent.interrupt.received` | turn 接受 steering、graceful interrupt 或 hard abort 指令时 | `interrupt_kind`, `role`, `content_len`, `queue_depth`, `hint_len` | +| `agent.subturn.spawn` | 父 turn 创建子 turn/subagent 时 | `child_agent_id`, `label`, `parent_turn_id` | +| `agent.subturn.end` | 子 turn 结束时 | `child_agent_id`, `status` | +| `agent.subturn.result_delivered` | 子 turn 结果成功投递到目标 channel/chat 时 | `target_channel`, `target_chat_id`, `content_len` | +| `agent.subturn.orphan` | 子 turn 结果无法投递或无法关联回父 turn 时 | `parent_turn_id`, `child_turn_id`, `reason` | +| `agent.error` | agent 执行流程报告错误时 | `stage`, `error` | + +### Channel + +| 事件名 | 触发时机 | 主要详情 | +| ------ | -------- | -------- | +| `channel.lifecycle.initialized` | channel manager 根据配置创建并注册 channel 实例后 | `type`; scope 包含 `channel` | +| `channel.lifecycle.started` | channel `Start()` 成功，worker 已启动时；热重载新增 channel 也会触发 | `type` | +| `channel.lifecycle.start_failed` | channel `Start()` 失败时 | `type`, `error`; severity 为 `error` | +| `channel.lifecycle.stopped` | channel `Stop()` 成功后 | `type` | +| `channel.webhook.registered` | channel 的 webhook handler 被注册到共享 HTTP mux 时 | `type`; scope 包含 `channel` | +| `channel.webhook.unregistered` | channel 的 webhook handler 从共享 HTTP mux 移除时 | `type`; scope 包含 `channel` | +| `channel.message.outbound_queued` | outbound 文本或媒体消息被放入对应 channel worker 队列时 | `media`, `content_len`, `reply_to_message_id`; scope 来自原 inbound context | +| `channel.message.outbound_sent` | outbound 文本或媒体消息成功发送，或 placeholder edit 已处理响应时 | `media`, `content_len`, `message_ids`, `reply_to_message_id` | +| `channel.message.outbound_failed` | outbound 文本或媒体消息重试耗尽或遇到永久失败时 | `media`, `content_len`, `retries`, `error`, `reply_to_message_id`; severity 为 `error` | +| `channel.rate_limited` | channel worker 等待 rate limiter token 时被 context 取消，导致本次发送被限流/中断 | `media`, `content_len`, `error`, `reply_to_message_id`; severity 为 `warn` | + +### Message Bus + +| 事件名 | 触发时机 | 主要详情 | +| ------ | -------- | -------- | +| `bus.publish.failed` | inbound、outbound、media、audio 或 voice control 发布失败，或缺少必要 context 时 | `stream`, `error`; scope 尽量来自消息 context | +| `bus.close.started` | message bus 开始关闭时 | `drained` 通常为 `0` | +| `bus.close.drained` | close 期间等待队列 drain，并且 drain 到至少一条 buffered message 时 | `drained` | +| `bus.close.completed` | message bus 完成关闭时 | `drained` | + +### Gateway + +| 事件名 | 触发时机 | 主要详情 | +| ------ | -------- | -------- | +| `gateway.start` | gateway 完成 agent/runtime event bus/bootstrap 绑定后 | `duration_ms` | +| `gateway.ready` | gateway 服务、channel manager、HTTP 等关键服务启动完成后 | `duration_ms` | +| `gateway.shutdown` | gateway 开始关闭流程时 | 无固定 payload，可能只有 envelope 字段 | +| `gateway.reload.started` | 热重载开始执行时 | `duration_ms` | +| `gateway.reload.completed` | 热重载成功完成时 | `duration_ms` | +| `gateway.reload.failed` | 热重载失败时 | `duration_ms`, `error`; severity 为 `error` | + +### MCP + +| 事件名 | 触发时机 | 主要详情 | +| ------ | -------- | -------- | +| `mcp.server.connecting` | MCP manager 准备连接某个 server 前 | `server`, `type`, `url`, `command` | +| `mcp.server.connected` | MCP server 连接成功并完成工具列表初始化后 | `server`, `type`, `url`, `command`, `tool_count` | +| `mcp.server.failed` | MCP server 连接失败，或 manager 已关闭导致无法连接时 | `server`, `type`, `url`, `command`, `error`; severity 为 `error` | +| `mcp.tool.discovered` | MCP server 的某个工具被发现并注册时 | `server`, `type`, `url`, `command`, `tool` | +| `mcp.tool.call.start` | MCP tool wrapper 开始执行一次远端工具调用前 | `server`, `tool`; 如果在 agent turn 内触发，scope 会带上对应 turn/chat 信息 | +| `mcp.tool.call.end` | MCP tool wrapper 完成一次远端工具调用后，包括失败结果 | `server`, `tool`, `duration_ms`, `is_error`, `error` | + +## 日志字段 + +所有事件日志都会尽量包含稳定 envelope 字段： + +- `event_id` +- `event_kind` +- `severity` +- `event_time` +- `source_component` +- `source_name` +- `agent_id` +- `session_key` +- `turn_id` +- `channel` +- `account` +- `chat_id` +- `topic_id` +- `space_id` +- `space_type` +- `chat_type` +- `sender_id` +- `message_id` +- `trace_id` +- `parent_turn_id` +- `request_id` +- `reply_to_id` + +agent 事件还会追加 payload 摘要字段： + +| 事件 | 摘要字段 | +| ---- | -------- | +| `agent.turn.start` | `user_len`, `media_count` | +| `agent.turn.end` | `status`, `iterations_total`, `duration_ms`, `final_len` | +| `agent.llm.request` | `model`, `messages`, `tools`, `max_tokens` | +| `agent.llm.delta` | `content_delta_len`, `reasoning_delta_len` | +| `agent.llm.response` | `content_len`, `tool_calls`, `has_reasoning` | +| `agent.llm.retry` | `attempt`, `max_retries`, `reason`, `error`, `backoff_ms` | +| `agent.context.compress` | `reason`, `dropped_messages`, `remaining_messages` | +| `agent.session.summarize` | `summarized_messages`, `kept_messages`, `summary_len`, `omitted_oversized` | +| `agent.tool.exec_start` | `tool`, `args_count` | +| `agent.tool.exec_end` | `tool`, `duration_ms`, `for_llm_len`, `for_user_len`, `is_error`, `async` | +| `agent.tool.exec_skipped` | `tool`, `reason` | +| `agent.steering.injected` | `count`, `total_content_len` | +| `agent.follow_up.queued` | `source_tool`, `content_len` | +| `agent.interrupt.received` | `interrupt_kind`, `role`, `content_len`, `queue_depth`, `hint_len` | +| `agent.subturn.spawn` | `child_agent_id`, `label` | +| `agent.subturn.end` | `child_agent_id`, `status` | +| `agent.subturn.result_delivered` | `target_channel`, `target_chat_id`, `content_len` | +| `agent.subturn.orphan` | `parent_turn_id`, `child_turn_id`, `reason` | +| `agent.error` | `stage`, `error` | + +## 可打印的事件域 + +当前 runtime event kind 定义在 `pkg/events/kind.go`。事件日志配置可以选择这些域： + +- `agent.*`：agent turn、LLM、tool、context、steering、interrupt、subturn、error。 +- `channel.*`：channel lifecycle、webhook 注册、outbound queued/sent/failed、rate limited。 +- `bus.*`：publish failed、close started/drained/completed。 +- `gateway.*`：start、ready、shutdown、reload started/completed/failed。 +- `mcp.*`：server connecting/connected/failed、tool discovered、tool call start/end。 + +默认事件日志示例见 [`../../config/config.example.json`](../../config/config.example.json)。 diff --git a/docs/guides/configuration.zh.md b/docs/guides/configuration.zh.md index dbc853d98..c41c3dae0 100644 --- a/docs/guides/configuration.zh.md +++ b/docs/guides/configuration.zh.md @@ -753,6 +753,42 @@ PicoClaw 按协议族路由提供商： +### 事件日志 + +PicoClaw 的 runtime events 会覆盖 agent、channel、gateway、message bus 和 MCP 等运行时组件。默认只打印 `agent.*` 事件，其他事件仍会发布到 runtime event bus，但不会进入日志。 + +```json +{ + "events": { + "logging": { + "enabled": true, + "include": ["agent.*"], + "exclude": [], + "min_severity": "info", + "include_payload": false + } + } +} +``` + +常用配置： + +```json +{ + "events": { + "logging": { + "include": ["*"], + "exclude": ["agent.llm.delta"], + "min_severity": "warn" + } + } +} +``` + +`include` / `exclude` 支持精确事件名和 `gateway.*`、`channel.lifecycle.*` 这类模式。`include_payload` 默认关闭，避免把完整用户消息或工具参数写入日志；agent 事件会默认输出长度、计数、状态等摘要字段。 + +更多字段说明和示例见 [Runtime Events 与事件日志](../architecture/runtime-events.zh.md)。 + ### 定时任务 / 提醒 PicoClaw 通过 `cron` 工具支持 cron 风格的定时任务。Agent 可以设置、列出和取消在指定时间触发的提醒或周期性任务。 @@ -775,6 +811,7 @@ PicoClaw 通过 `cron` 工具支持 cron 风格的定时任务。Agent 可以设 | 主题 | 说明 | | ---- | ---- | | [敏感数据过滤](../security/sensitive_data_filtering.zh.md) | 在发送给 LLM 前，从工具结果中过滤 API 密钥和令牌 | +| [Runtime Events 与事件日志](../architecture/runtime-events.zh.md) | 统一运行时事件、日志过滤和调试配置 | | [Hook 系统](../architecture/hooks/README.zh.md) | 事件驱动 Hook：观察者、拦截器、审批 Hook | | [Steering](../architecture/steering.md) | 在工具调用间向运行中的 Agent 注入消息 | | [SubTurn](../architecture/subturn.md) | 子 Agent 协调、并发控制、生命周期管理 | diff --git a/pkg/agent/agent.go b/pkg/agent/agent.go index 7a9384a23..a394a6e97 100644 --- a/pkg/agent/agent.go +++ b/pkg/agent/agent.go @@ -39,9 +39,10 @@ type AgentLoop struct { state *state.Manager // Runtime event system - runtimeEvents runtimeevents.Bus - ownsRuntimeEvents bool - hooks *HookManager + runtimeEvents runtimeevents.Bus + ownsRuntimeEvents bool + runtimeEventLogSub runtimeevents.Subscription + hooks *HookManager // Runtime state running atomic.Bool @@ -285,6 +286,9 @@ func (al *AgentLoop) Close() { if al.hooks != nil { al.hooks.Close() } + if al.runtimeEventLogSub != nil { + _ = al.runtimeEventLogSub.Close() + } if al.runtimeEvents != nil && al.ownsRuntimeEvents { if err := al.runtimeEvents.Close(); err != nil { logger.ErrorCF("agent", "Failed to close runtime event bus", diff --git a/pkg/agent/agent_event.go b/pkg/agent/agent_event.go index d4174ced5..99ea2a18e 100644 --- a/pkg/agent/agent_event.go +++ b/pkg/agent/agent_event.go @@ -6,7 +6,6 @@ import ( "fmt" runtimeevents "github.com/sipeed/picoclaw/pkg/events" - "github.com/sipeed/picoclaw/pkg/logger" ) func (al *AgentLoop) newTurnEventScope(agentID, sessionKey string, turnCtx *TurnContext) turnEventScope { @@ -48,108 +47,9 @@ func (al *AgentLoop) emitEvent(kind runtimeevents.Kind, meta HookMeta, payload a return } - al.logEvent(evt, clonedMeta, eventCtx) - al.publishRuntimeEvent(evt) } -func (al *AgentLoop) logEvent(evt runtimeevents.Event, meta HookMeta, eventCtx *TurnContext) { - fields := map[string]any{ - "event_kind": evt.Kind.String(), - "agent_id": meta.AgentID, - "turn_id": meta.TurnID, - "session_key": meta.SessionKey, - "iteration": meta.Iteration, - } - - if meta.TracePath != "" { - fields["trace"] = meta.TracePath - } - if meta.Source != "" { - fields["source"] = meta.Source - } - - appendEventContextFields(fields, eventCtx) - - switch payload := evt.Payload.(type) { - case TurnStartPayload: - fields["user_len"] = len(payload.UserMessage) - fields["media_count"] = payload.MediaCount - case TurnEndPayload: - fields["status"] = payload.Status - fields["iterations_total"] = payload.Iterations - fields["duration_ms"] = payload.Duration.Milliseconds() - fields["final_len"] = payload.FinalContentLen - case LLMRequestPayload: - fields["model"] = payload.Model - fields["messages"] = payload.MessagesCount - fields["tools"] = payload.ToolsCount - fields["max_tokens"] = payload.MaxTokens - case LLMDeltaPayload: - fields["content_delta_len"] = payload.ContentDeltaLen - fields["reasoning_delta_len"] = payload.ReasoningDeltaLen - case LLMResponsePayload: - fields["content_len"] = payload.ContentLen - fields["tool_calls"] = payload.ToolCalls - fields["has_reasoning"] = payload.HasReasoning - case LLMRetryPayload: - fields["attempt"] = payload.Attempt - fields["max_retries"] = payload.MaxRetries - fields["reason"] = payload.Reason - fields["error"] = payload.Error - fields["backoff_ms"] = payload.Backoff.Milliseconds() - case ContextCompressPayload: - fields["reason"] = payload.Reason - fields["dropped_messages"] = payload.DroppedMessages - fields["remaining_messages"] = payload.RemainingMessages - case SessionSummarizePayload: - fields["summarized_messages"] = payload.SummarizedMessages - fields["kept_messages"] = payload.KeptMessages - fields["summary_len"] = payload.SummaryLen - fields["omitted_oversized"] = payload.OmittedOversized - case ToolExecStartPayload: - fields["tool"] = payload.Tool - fields["args_count"] = len(payload.Arguments) - case ToolExecEndPayload: - fields["tool"] = payload.Tool - fields["duration_ms"] = payload.Duration.Milliseconds() - fields["for_llm_len"] = payload.ForLLMLen - fields["for_user_len"] = payload.ForUserLen - fields["is_error"] = payload.IsError - fields["async"] = payload.Async - case ToolExecSkippedPayload: - fields["tool"] = payload.Tool - fields["reason"] = payload.Reason - case SteeringInjectedPayload: - fields["count"] = payload.Count - fields["total_content_len"] = payload.TotalContentLen - case FollowUpQueuedPayload: - fields["source_tool"] = payload.SourceTool - fields["content_len"] = payload.ContentLen - case InterruptReceivedPayload: - fields["interrupt_kind"] = payload.Kind - fields["role"] = payload.Role - fields["content_len"] = payload.ContentLen - fields["queue_depth"] = payload.QueueDepth - fields["hint_len"] = payload.HintLen - case SubTurnSpawnPayload: - fields["child_agent_id"] = payload.AgentID - fields["label"] = payload.Label - case SubTurnEndPayload: - fields["child_agent_id"] = payload.AgentID - fields["status"] = payload.Status - case SubTurnResultDeliveredPayload: - fields["target_channel"] = payload.TargetChannel - fields["target_chat_id"] = payload.TargetChatID - fields["content_len"] = payload.ContentLen - case ErrorPayload: - fields["stage"] = payload.Stage - fields["error"] = payload.Message - } - - logger.InfoCF("eventbus", fmt.Sprintf("Agent event: %s", evt.Kind.String()), fields) -} - // MountHook registers an in-process hook on the agent loop. func (al *AgentLoop) MountHook(reg HookRegistration) error { if al == nil || al.hooks == nil { diff --git a/pkg/agent/agent_init.go b/pkg/agent/agent_init.go index 7ad884cfe..b8e535c36 100644 --- a/pkg/agent/agent_init.go +++ b/pkg/agent/agent_init.go @@ -75,6 +75,7 @@ func NewAgentLoop( al.runtimeEvents = runtimeevents.NewBus() al.ownsRuntimeEvents = true } + al.runtimeEventLogSub = subscribeRuntimeEventLogger(cfg, al.runtimeEvents) al.providerFactory = providers.CreateProviderFromConfig al.hooks = NewHookManager(al.runtimeEvents.Channel()) configureHookManagerFromConfig(al.hooks, cfg) diff --git a/pkg/agent/runtime_event_logger.go b/pkg/agent/runtime_event_logger.go new file mode 100644 index 000000000..4922c9021 --- /dev/null +++ b/pkg/agent/runtime_event_logger.go @@ -0,0 +1,316 @@ +package agent + +import ( + "context" + "fmt" + "path" + "strings" + "time" + + "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" + "github.com/sipeed/picoclaw/pkg/logger" +) + +const runtimeEventLoggerBuffer = 256 + +type runtimeEventLogger struct { + cfg config.EventLoggingConfig +} + +func subscribeRuntimeEventLogger(cfg *config.Config, eventBus runtimeevents.Bus) runtimeevents.Subscription { + eventLogger := newRuntimeEventLogger(cfg) + sub, err := eventLogger.subscribe(context.Background(), eventBus) + if err != nil { + logger.WarnCF("events", "Failed to subscribe runtime event logger", map[string]any{"error": err.Error()}) + return nil + } + return sub +} + +func newRuntimeEventLogger(cfg *config.Config) *runtimeEventLogger { + logCfg := config.EffectiveEventLoggingConfig(cfg) + if !logCfg.Enabled { + return nil + } + return &runtimeEventLogger{cfg: logCfg} +} + +func (l *runtimeEventLogger) subscribe( + ctx context.Context, + eventBus runtimeevents.Bus, +) (runtimeevents.Subscription, error) { + if l == nil || eventBus == nil { + return nil, nil + } + return eventBus.Channel().Subscribe(ctx, runtimeevents.SubscribeOptions{ + Name: "runtime-event-logger", + Buffer: runtimeEventLoggerBuffer, + Concurrency: runtimeevents.Locked, + Backpressure: runtimeevents.DropNewest, + PanicPolicy: runtimeevents.RecoverAndLog, + }, l.handle) +} + +func (l *runtimeEventLogger) handle(_ context.Context, evt runtimeevents.Event) error { + if l == nil || !l.shouldLog(evt) { + return nil + } + + fields := runtimeEventLogFields(evt) + if l.cfg.IncludePayload && evt.Payload != nil { + fields["payload"] = evt.Payload + } + + logRuntimeEvent(evt, fields) + return nil +} + +func (l *runtimeEventLogger) shouldLog(evt runtimeevents.Event) bool { + if l == nil || !l.cfg.Enabled { + return false + } + if runtimeEventSeverityRank(evt.Severity) < runtimeEventSeverityRank(parseRuntimeEventSeverity(l.cfg.MinSeverity)) { + return false + } + + kind := evt.Kind.String() + if !matchAnyRuntimeEventPattern(l.cfg.Include, kind, true) { + return false + } + return !matchAnyRuntimeEventPattern(l.cfg.Exclude, kind, false) +} + +func logRuntimeEvent(evt runtimeevents.Event, fields map[string]any) { + message := fmt.Sprintf("Runtime event: %s", evt.Kind.String()) + switch normalizeRuntimeEventSeverity(evt.Severity) { + case runtimeevents.SeverityDebug: + logger.DebugCF("events", message, fields) + case runtimeevents.SeverityWarn: + logger.WarnCF("events", message, fields) + case runtimeevents.SeverityError: + logger.ErrorCF("events", message, fields) + default: + logger.InfoCF("events", message, fields) + } +} + +func runtimeEventLogFields(evt runtimeevents.Event) map[string]any { + fields := map[string]any{ + "event_id": evt.ID, + "event_kind": evt.Kind.String(), + "severity": string(normalizeRuntimeEventSeverity(evt.Severity)), + } + if !evt.Time.IsZero() { + fields["event_time"] = evt.Time.Format(time.RFC3339Nano) + } + appendRuntimeEventSourceFields(fields, evt.Source) + appendRuntimeEventScopeFields(fields, evt.Scope) + appendRuntimeEventCorrelationFields(fields, evt.Correlation) + appendRuntimeEventAttrs(fields, evt.Attrs) + appendRuntimeEventPayloadSummary(fields, evt.Payload) + return fields +} + +func appendRuntimeEventSourceFields(fields map[string]any, source runtimeevents.Source) { + if source.Component != "" { + fields["source_component"] = source.Component + } + if source.Name != "" { + fields["source_name"] = source.Name + } +} + +func appendRuntimeEventScopeFields(fields map[string]any, scope runtimeevents.Scope) { + setStringField(fields, "runtime_id", scope.RuntimeID) + setStringField(fields, "agent_id", scope.AgentID) + setStringField(fields, "session_key", scope.SessionKey) + setStringField(fields, "turn_id", scope.TurnID) + setStringField(fields, "channel", scope.Channel) + setStringField(fields, "account", scope.Account) + setStringField(fields, "chat_id", scope.ChatID) + setStringField(fields, "topic_id", scope.TopicID) + setStringField(fields, "space_id", scope.SpaceID) + setStringField(fields, "space_type", scope.SpaceType) + setStringField(fields, "chat_type", scope.ChatType) + setStringField(fields, "sender_id", scope.SenderID) + setStringField(fields, "message_id", scope.MessageID) +} + +func appendRuntimeEventCorrelationFields(fields map[string]any, correlation runtimeevents.Correlation) { + setStringField(fields, "trace_id", correlation.TraceID) + setStringField(fields, "parent_turn_id", correlation.ParentTurnID) + setStringField(fields, "request_id", correlation.RequestID) + setStringField(fields, "reply_to_id", correlation.ReplyToID) +} + +func appendRuntimeEventAttrs(fields map[string]any, attrs map[string]any) { + for key, value := range attrs { + if key == "" || value == nil { + continue + } + if _, exists := fields[key]; exists { + fields["attr_"+key] = value + continue + } + fields[key] = value + } +} + +func appendRuntimeEventPayloadSummary(fields map[string]any, payload any) { + switch payload := payload.(type) { + case TurnStartPayload: + fields["user_len"] = len(payload.UserMessage) + fields["media_count"] = payload.MediaCount + case TurnEndPayload: + fields["status"] = payload.Status + fields["iterations_total"] = payload.Iterations + fields["duration_ms"] = payload.Duration.Milliseconds() + fields["final_len"] = payload.FinalContentLen + case LLMRequestPayload: + fields["model"] = payload.Model + fields["messages"] = payload.MessagesCount + fields["tools"] = payload.ToolsCount + fields["max_tokens"] = payload.MaxTokens + case LLMDeltaPayload: + fields["content_delta_len"] = payload.ContentDeltaLen + fields["reasoning_delta_len"] = payload.ReasoningDeltaLen + case LLMResponsePayload: + fields["content_len"] = payload.ContentLen + fields["tool_calls"] = payload.ToolCalls + fields["has_reasoning"] = payload.HasReasoning + case LLMRetryPayload: + fields["attempt"] = payload.Attempt + fields["max_retries"] = payload.MaxRetries + fields["reason"] = payload.Reason + fields["error"] = payload.Error + fields["backoff_ms"] = payload.Backoff.Milliseconds() + case ContextCompressPayload: + fields["reason"] = payload.Reason + fields["dropped_messages"] = payload.DroppedMessages + fields["remaining_messages"] = payload.RemainingMessages + case SessionSummarizePayload: + fields["summarized_messages"] = payload.SummarizedMessages + fields["kept_messages"] = payload.KeptMessages + fields["summary_len"] = payload.SummaryLen + fields["omitted_oversized"] = payload.OmittedOversized + case ToolExecStartPayload: + fields["tool"] = payload.Tool + fields["args_count"] = len(payload.Arguments) + case ToolExecEndPayload: + fields["tool"] = payload.Tool + fields["duration_ms"] = payload.Duration.Milliseconds() + fields["for_llm_len"] = payload.ForLLMLen + fields["for_user_len"] = payload.ForUserLen + fields["is_error"] = payload.IsError + fields["async"] = payload.Async + case ToolExecSkippedPayload: + fields["tool"] = payload.Tool + fields["reason"] = payload.Reason + case SteeringInjectedPayload: + fields["count"] = payload.Count + fields["total_content_len"] = payload.TotalContentLen + case FollowUpQueuedPayload: + fields["source_tool"] = payload.SourceTool + fields["content_len"] = payload.ContentLen + case InterruptReceivedPayload: + fields["interrupt_kind"] = payload.Kind + fields["role"] = payload.Role + fields["content_len"] = payload.ContentLen + fields["queue_depth"] = payload.QueueDepth + fields["hint_len"] = payload.HintLen + case SubTurnSpawnPayload: + fields["child_agent_id"] = payload.AgentID + fields["label"] = payload.Label + case SubTurnEndPayload: + fields["child_agent_id"] = payload.AgentID + fields["status"] = payload.Status + case SubTurnResultDeliveredPayload: + fields["target_channel"] = payload.TargetChannel + fields["target_chat_id"] = payload.TargetChatID + fields["content_len"] = payload.ContentLen + case SubTurnOrphanPayload: + fields["parent_turn_id"] = payload.ParentTurnID + fields["child_turn_id"] = payload.ChildTurnID + fields["reason"] = payload.Reason + case ErrorPayload: + fields["stage"] = payload.Stage + fields["error"] = payload.Message + } +} + +func setStringField(fields map[string]any, key, value string) { + if value != "" { + fields[key] = value + } +} + +func matchAnyRuntimeEventPattern(patterns []string, kind string, emptyMatches bool) bool { + if len(patterns) == 0 { + return emptyMatches + } + for _, pattern := range patterns { + if matchRuntimeEventPattern(pattern, kind) { + return true + } + } + return false +} + +func matchRuntimeEventPattern(pattern, kind string) bool { + pattern = strings.TrimSpace(pattern) + if pattern == "" { + return false + } + if pattern == "*" { + return true + } + if strings.HasSuffix(pattern, ".*") { + return strings.HasPrefix(kind, strings.TrimSuffix(pattern, "*")) + } + matched, err := path.Match(pattern, kind) + if err == nil { + return matched + } + return pattern == kind +} + +func parseRuntimeEventSeverity(severity string) runtimeevents.Severity { + switch strings.ToLower(strings.TrimSpace(severity)) { + case "debug": + return runtimeevents.SeverityDebug + case "warn", "warning": + return runtimeevents.SeverityWarn + case "error": + return runtimeevents.SeverityError + default: + return runtimeevents.SeverityInfo + } +} + +func normalizeRuntimeEventSeverity(severity runtimeevents.Severity) runtimeevents.Severity { + switch severity { + case runtimeevents.SeverityDebug, + runtimeevents.SeverityInfo, + runtimeevents.SeverityWarn, + runtimeevents.SeverityError: + return severity + default: + return runtimeevents.SeverityInfo + } +} + +func runtimeEventSeverityRank(severity runtimeevents.Severity) int { + switch normalizeRuntimeEventSeverity(severity) { + case runtimeevents.SeverityDebug: + return 0 + case runtimeevents.SeverityInfo: + return 1 + case runtimeevents.SeverityWarn: + return 2 + case runtimeevents.SeverityError: + return 3 + default: + return 1 + } +} diff --git a/pkg/agent/runtime_event_logger_test.go b/pkg/agent/runtime_event_logger_test.go new file mode 100644 index 000000000..d056eb15c --- /dev/null +++ b/pkg/agent/runtime_event_logger_test.go @@ -0,0 +1,99 @@ +package agent + +import ( + "testing" + + "github.com/sipeed/picoclaw/pkg/config" + runtimeevents "github.com/sipeed/picoclaw/pkg/events" +) + +func TestRuntimeEventLoggerFiltering(t *testing.T) { + cfg := config.DefaultConfig() + eventLogger := newRuntimeEventLogger(cfg) + if eventLogger == nil { + t.Fatal("default runtime event logger is nil") + } + + if !eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindAgentTurnStart, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("default config should log agent events") + } + if eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindChannelLifecycleStarted, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("default config should not log non-agent events") + } + + cfg.Events.Logging.Include = []string{"*"} + cfg.Events.Logging.Exclude = []string{"mcp.*"} + eventLogger = newRuntimeEventLogger(cfg) + if !eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindGatewayReady, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("include * should log gateway events") + } + if eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindMCPServerConnected, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("exclude mcp.* should suppress MCP events") + } + + cfg.Events.Logging.Exclude = nil + cfg.Events.Logging.MinSeverity = "warn" + eventLogger = newRuntimeEventLogger(cfg) + if eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindGatewayReady, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("min severity warn should suppress info events") + } + if !eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindGatewayReloadFailed, + Severity: runtimeevents.SeverityError, + }) { + t.Fatal("min severity warn should allow error events") + } + + cfg.Events.Logging.Enabled = false + if newRuntimeEventLogger(cfg) != nil { + t.Fatal("disabled config should not create runtime event logger") + } +} + +func TestRuntimeEventLogFieldsSummarizeAgentPayload(t *testing.T) { + fields := runtimeEventLogFields(runtimeevents.Event{ + ID: "evt-test", + Kind: runtimeevents.KindAgentToolExecStart, + Severity: runtimeevents.SeverityInfo, + Source: runtimeevents.Source{ + Component: "agent", + Name: "main", + }, + Scope: runtimeevents.Scope{ + AgentID: "main", + SessionKey: "session-1", + TurnID: "turn-1", + }, + Payload: ToolExecStartPayload{ + Tool: "exec", + Arguments: map[string]any{ + "secret": "should-not-be-logged-by-default", + }, + }, + }) + + if fields["event_id"] != "evt-test" || fields["source_component"] != "agent" { + t.Fatalf("missing common event fields: %#v", fields) + } + if fields["tool"] != "exec" || fields["args_count"] != 1 { + t.Fatalf("missing safe agent payload summary fields: %#v", fields) + } + if _, ok := fields["payload"]; ok { + t.Fatalf("raw payload should not be included by runtimeEventLogFields: %#v", fields) + } +} diff --git a/pkg/config/config.go b/pkg/config/config.go index 6bb8d3ce6..35e217e78 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -39,6 +39,7 @@ type Config struct { Channels ChannelsConfig `json:"channel_list" yaml:"channel_list"` ModelList SecureModelList `json:"model_list" yaml:"model_list"` // New model-centric provider configuration Gateway GatewayConfig `json:"gateway" yaml:"-"` + Events EventsConfig `json:"events,omitempty" yaml:"-"` Hooks HooksConfig `json:"hooks,omitempty" yaml:"-"` Tools ToolsConfig `json:"tools" yaml:",inline"` Heartbeat HeartbeatConfig `json:"heartbeat" yaml:"-"` diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index f3aaca7ab..f7490dfed 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -294,6 +294,9 @@ func DefaultConfig() *Config { HotReload: false, LogLevel: DefaultGatewayLogLevel, }, + Events: EventsConfig{ + Logging: defaultEventLoggingConfig(), + }, Tools: ToolsConfig{ FilterSensitiveData: true, FilterMinLength: 8, diff --git a/pkg/config/events.go b/pkg/config/events.go new file mode 100644 index 000000000..54a2ce709 --- /dev/null +++ b/pkg/config/events.go @@ -0,0 +1,48 @@ +package config + +// EventsConfig groups runtime event configuration. +type EventsConfig struct { + Logging EventLoggingConfig `json:"logging,omitempty" envPrefix:"PICOCLAW_EVENTS_LOGGING_"` +} + +// EventLoggingConfig controls centralized runtime event logging. +type EventLoggingConfig struct { + // Enabled controls whether runtime events are printed by the built-in logger. + Enabled bool `json:"enabled" env:"ENABLED"` + // Include contains exact event kinds or glob patterns such as "agent.*" or "*". + Include []string `json:"include,omitempty" env:"INCLUDE"` + // Exclude contains exact event kinds or glob patterns to suppress after Include matches. + Exclude []string `json:"exclude,omitempty" env:"EXCLUDE"` + // MinSeverity filters out events below the configured severity: debug, info, warn, or error. + MinSeverity string `json:"min_severity,omitempty" env:"MIN_SEVERITY"` + // IncludePayload adds the raw payload to logs. Leave disabled unless detailed diagnostics are needed. + IncludePayload bool `json:"include_payload,omitempty" env:"INCLUDE_PAYLOAD"` +} + +// DefaultEventLoggingInclude keeps the pre-existing behavior where agent events +// are printed, while non-agent runtime events are published for subscribers only. +var DefaultEventLoggingInclude = []string{"agent.*"} + +// EffectiveEventLoggingConfig returns a logging config with stable defaults. +func EffectiveEventLoggingConfig(cfg *Config) EventLoggingConfig { + if cfg == nil { + return defaultEventLoggingConfig() + } + + out := cfg.Events.Logging + if out.MinSeverity == "" { + out.MinSeverity = "info" + } + if len(out.Include) == 0 { + out.Include = append([]string(nil), DefaultEventLoggingInclude...) + } + return out +} + +func defaultEventLoggingConfig() EventLoggingConfig { + return EventLoggingConfig{ + Enabled: true, + Include: append([]string(nil), DefaultEventLoggingInclude...), + MinSeverity: "info", + } +} diff --git a/pkg/config/events_test.go b/pkg/config/events_test.go new file mode 100644 index 000000000..6cd410492 --- /dev/null +++ b/pkg/config/events_test.go @@ -0,0 +1,103 @@ +package config + +import ( + "os" + "path/filepath" + "reflect" + "testing" +) + +func TestDefaultEventLoggingConfig(t *testing.T) { + cfg := DefaultConfig() + logCfg := EffectiveEventLoggingConfig(cfg) + + if !logCfg.Enabled { + t.Fatal("default event logging should be enabled") + } + if !reflect.DeepEqual(logCfg.Include, []string{"agent.*"}) { + t.Fatalf("default include = %#v, want agent.*", logCfg.Include) + } + if logCfg.MinSeverity != "info" { + t.Fatalf("default min severity = %q, want info", logCfg.MinSeverity) + } + if logCfg.IncludePayload { + t.Fatal("default event logging should not include raw payloads") + } +} + +func TestLoadConfigEventLoggingOverrides(t *testing.T) { + path := filepath.Join(t.TempDir(), "config.json") + data := []byte(`{ + "version": 3, + "events": { + "logging": { + "enabled": false, + "include": ["gateway.*"], + "exclude": ["gateway.ready"], + "min_severity": "warn", + "include_payload": true + } + } + }`) + if err := os.WriteFile(path, data, 0o600); err != nil { + t.Fatalf("write config: %v", err) + } + + cfg, err := LoadConfig(path) + if err != nil { + t.Fatalf("LoadConfig() error: %v", err) + } + logCfg := EffectiveEventLoggingConfig(cfg) + + if logCfg.Enabled { + t.Fatal("loaded event logging enabled = true, want false") + } + if !reflect.DeepEqual(logCfg.Include, []string{"gateway.*"}) { + t.Fatalf("loaded include = %#v, want gateway.*", logCfg.Include) + } + if !reflect.DeepEqual(logCfg.Exclude, []string{"gateway.ready"}) { + t.Fatalf("loaded exclude = %#v, want gateway.ready", logCfg.Exclude) + } + if logCfg.MinSeverity != "warn" { + t.Fatalf("loaded min severity = %q, want warn", logCfg.MinSeverity) + } + if !logCfg.IncludePayload { + t.Fatal("loaded include_payload = false, want true") + } +} + +func TestLoadConfigEventLoggingEnvOverrides(t *testing.T) { + t.Setenv("PICOCLAW_EVENTS_LOGGING_ENABLED", "false") + t.Setenv("PICOCLAW_EVENTS_LOGGING_INCLUDE", "gateway.*,channel.lifecycle.*") + t.Setenv("PICOCLAW_EVENTS_LOGGING_EXCLUDE", "gateway.ready") + t.Setenv("PICOCLAW_EVENTS_LOGGING_MIN_SEVERITY", "error") + t.Setenv("PICOCLAW_EVENTS_LOGGING_INCLUDE_PAYLOAD", "true") + + path := filepath.Join(t.TempDir(), "config.json") + data := []byte(`{"version": 3}`) + if err := os.WriteFile(path, data, 0o600); err != nil { + t.Fatalf("write config: %v", err) + } + + cfg, err := LoadConfig(path) + if err != nil { + t.Fatalf("LoadConfig() error: %v", err) + } + logCfg := EffectiveEventLoggingConfig(cfg) + + if logCfg.Enabled { + t.Fatal("env enabled override = true, want false") + } + if !reflect.DeepEqual(logCfg.Include, []string{"gateway.*", "channel.lifecycle.*"}) { + t.Fatalf("env include = %#v, want gateway/channel lifecycle", logCfg.Include) + } + if !reflect.DeepEqual(logCfg.Exclude, []string{"gateway.ready"}) { + t.Fatalf("env exclude = %#v, want gateway.ready", logCfg.Exclude) + } + if logCfg.MinSeverity != "error" { + t.Fatalf("env min severity = %q, want error", logCfg.MinSeverity) + } + if !logCfg.IncludePayload { + t.Fatal("env include_payload = false, want true") + } +} From 4d6337fd262a8915fad272b5369cffaf39f3819c Mon Sep 17 00:00:00 2001 From: Hoshina Date: Sun, 26 Apr 2026 19:28:26 +0800 Subject: [PATCH 25/53] fix runtime event logger reload and shutdown --- pkg/agent/agent.go | 7 +- pkg/agent/agent_init.go | 2 +- pkg/agent/agent_test.go | 5 +- pkg/agent/runtime_event_logger.go | 114 +++++++++++++++++++-- pkg/agent/runtime_event_logger_test.go | 134 +++++++++++++++++++++++++ pkg/events/subscription.go | 24 ++++- pkg/events/subscription_test.go | 59 +++++++++++ 7 files changed, 327 insertions(+), 18 deletions(-) diff --git a/pkg/agent/agent.go b/pkg/agent/agent.go index a394a6e97..7b3b8bc11 100644 --- a/pkg/agent/agent.go +++ b/pkg/agent/agent.go @@ -41,6 +41,8 @@ type AgentLoop struct { // Runtime event system runtimeEvents runtimeevents.Bus ownsRuntimeEvents bool + runtimeEventLogMu sync.RWMutex + runtimeEventLogger *runtimeEventLogger runtimeEventLogSub runtimeevents.Subscription hooks *HookManager @@ -286,9 +288,7 @@ func (al *AgentLoop) Close() { if al.hooks != nil { al.hooks.Close() } - if al.runtimeEventLogSub != nil { - _ = al.runtimeEventLogSub.Close() - } + al.closeRuntimeEventLogger() if al.runtimeEvents != nil && al.ownsRuntimeEvents { if err := al.runtimeEvents.Close(); err != nil { logger.ErrorCF("agent", "Failed to close runtime event bus", @@ -387,6 +387,7 @@ func (al *AgentLoop) ReloadProviderAndConfig( al.fallback = providers.NewFallbackChain(providers.NewCooldownTracker(), newRL) al.mu.Unlock() + al.refreshRuntimeEventLogger(cfg) oldMCPManager := al.mcp.reset() al.hookRuntime.reset(al) diff --git a/pkg/agent/agent_init.go b/pkg/agent/agent_init.go index b8e535c36..035432e2e 100644 --- a/pkg/agent/agent_init.go +++ b/pkg/agent/agent_init.go @@ -75,7 +75,7 @@ func NewAgentLoop( al.runtimeEvents = runtimeevents.NewBus() al.ownsRuntimeEvents = true } - al.runtimeEventLogSub = subscribeRuntimeEventLogger(cfg, al.runtimeEvents) + al.refreshRuntimeEventLogger(cfg) al.providerFactory = providers.CreateProviderFromConfig al.hooks = NewHookManager(al.runtimeEvents.Channel()) configureHookManagerFromConfig(al.hooks, cfg) diff --git a/pkg/agent/agent_test.go b/pkg/agent/agent_test.go index 13c5b21a0..1005be512 100644 --- a/pkg/agent/agent_test.go +++ b/pkg/agent/agent_test.go @@ -5190,6 +5190,7 @@ func TestParallelMessageProcessing_SameSessionProcessedSequentially(t *testing.T var mu sync.Mutex turnIDs := make(map[string]bool) var wg sync.WaitGroup + var firstResponse sync.Once wg.Add(1) // Only 1 turn should be created for same session cfg := &config.Config{ @@ -5212,7 +5213,9 @@ func TestParallelMessageProcessing_SameSessionProcessedSequentially(t *testing.T al := NewAgentLoop(cfg, msgBus, &concurrentMockProvider{ responseFunc: func(callID int) string { - wg.Done() + firstResponse.Do(func() { + wg.Done() + }) return "ok" }, }) diff --git a/pkg/agent/runtime_event_logger.go b/pkg/agent/runtime_event_logger.go index 4922c9021..1035ffe35 100644 --- a/pkg/agent/runtime_event_logger.go +++ b/pkg/agent/runtime_event_logger.go @@ -5,6 +5,7 @@ import ( "fmt" "path" "strings" + "sync" "time" "github.com/sipeed/picoclaw/pkg/config" @@ -12,20 +13,85 @@ import ( "github.com/sipeed/picoclaw/pkg/logger" ) -const runtimeEventLoggerBuffer = 256 +const ( + runtimeEventLoggerBuffer = 256 + runtimeEventLoggerDrainTimeout = 2 * time.Second +) type runtimeEventLogger struct { + mu sync.RWMutex cfg config.EventLoggingConfig } -func subscribeRuntimeEventLogger(cfg *config.Config, eventBus runtimeevents.Bus) runtimeevents.Subscription { - eventLogger := newRuntimeEventLogger(cfg) - sub, err := eventLogger.subscribe(context.Background(), eventBus) +func (al *AgentLoop) refreshRuntimeEventLogger(cfg *config.Config) { + if al == nil { + return + } + logCfg := config.EffectiveEventLoggingConfig(cfg) + + al.runtimeEventLogMu.Lock() + if !logCfg.Enabled { + oldSub := al.runtimeEventLogSub + al.runtimeEventLogger = nil + al.runtimeEventLogSub = nil + al.runtimeEventLogMu.Unlock() + closeRuntimeEventLoggerSubscription(oldSub) + return + } + + if al.runtimeEventLogger != nil && al.runtimeEventLogSub != nil { + al.runtimeEventLogger.updateConfig(logCfg) + al.runtimeEventLogMu.Unlock() + return + } + al.runtimeEventLogMu.Unlock() + + eventLogger := newRuntimeEventLoggerFromConfig(logCfg) + sub, err := eventLogger.subscribe(context.Background(), al.runtimeEvents) if err != nil { logger.WarnCF("events", "Failed to subscribe runtime event logger", map[string]any{"error": err.Error()}) - return nil + return + } + + al.runtimeEventLogMu.Lock() + oldSub := al.runtimeEventLogSub + al.runtimeEventLogger = eventLogger + al.runtimeEventLogSub = sub + al.runtimeEventLogMu.Unlock() + closeRuntimeEventLoggerSubscription(oldSub) +} + +func (al *AgentLoop) closeRuntimeEventLogger() { + if al == nil { + return + } + al.runtimeEventLogMu.Lock() + oldSub := al.runtimeEventLogSub + al.runtimeEventLogger = nil + al.runtimeEventLogSub = nil + al.runtimeEventLogMu.Unlock() + closeRuntimeEventLoggerSubscription(oldSub) +} + +func closeRuntimeEventLoggerSubscription(sub runtimeevents.Subscription) { + if sub == nil { + return + } + if err := sub.Close(); err != nil { + logger.WarnCF("events", "Failed to close runtime event logger subscription", map[string]any{ + "error": err.Error(), + }) + } + + timer := time.NewTimer(runtimeEventLoggerDrainTimeout) + defer timer.Stop() + select { + case <-sub.Done(): + case <-timer.C: + logger.WarnCF("events", "Timed out waiting for runtime event logger to drain", map[string]any{ + "timeout": runtimeEventLoggerDrainTimeout.String(), + }) } - return sub } func newRuntimeEventLogger(cfg *config.Config) *runtimeEventLogger { @@ -33,9 +99,31 @@ func newRuntimeEventLogger(cfg *config.Config) *runtimeEventLogger { if !logCfg.Enabled { return nil } + return newRuntimeEventLoggerFromConfig(logCfg) +} + +func newRuntimeEventLoggerFromConfig(logCfg config.EventLoggingConfig) *runtimeEventLogger { return &runtimeEventLogger{cfg: logCfg} } +func (l *runtimeEventLogger) updateConfig(cfg config.EventLoggingConfig) { + if l == nil { + return + } + l.mu.Lock() + l.cfg = cfg + l.mu.Unlock() +} + +func (l *runtimeEventLogger) configSnapshot() config.EventLoggingConfig { + if l == nil { + return config.EventLoggingConfig{} + } + l.mu.RLock() + defer l.mu.RUnlock() + return l.cfg +} + func (l *runtimeEventLogger) subscribe( ctx context.Context, eventBus runtimeevents.Bus, @@ -58,7 +146,7 @@ func (l *runtimeEventLogger) handle(_ context.Context, evt runtimeevents.Event) } fields := runtimeEventLogFields(evt) - if l.cfg.IncludePayload && evt.Payload != nil { + if l.configSnapshot().IncludePayload && evt.Payload != nil { fields["payload"] = evt.Payload } @@ -67,18 +155,22 @@ func (l *runtimeEventLogger) handle(_ context.Context, evt runtimeevents.Event) } func (l *runtimeEventLogger) shouldLog(evt runtimeevents.Event) bool { - if l == nil || !l.cfg.Enabled { + if l == nil { return false } - if runtimeEventSeverityRank(evt.Severity) < runtimeEventSeverityRank(parseRuntimeEventSeverity(l.cfg.MinSeverity)) { + cfg := l.configSnapshot() + if !cfg.Enabled { + return false + } + if runtimeEventSeverityRank(evt.Severity) < runtimeEventSeverityRank(parseRuntimeEventSeverity(cfg.MinSeverity)) { return false } kind := evt.Kind.String() - if !matchAnyRuntimeEventPattern(l.cfg.Include, kind, true) { + if !matchAnyRuntimeEventPattern(cfg.Include, kind, true) { return false } - return !matchAnyRuntimeEventPattern(l.cfg.Exclude, kind, false) + return !matchAnyRuntimeEventPattern(cfg.Exclude, kind, false) } func logRuntimeEvent(evt runtimeevents.Event, fields map[string]any) { diff --git a/pkg/agent/runtime_event_logger_test.go b/pkg/agent/runtime_event_logger_test.go index d056eb15c..a64529314 100644 --- a/pkg/agent/runtime_event_logger_test.go +++ b/pkg/agent/runtime_event_logger_test.go @@ -1,8 +1,12 @@ package agent import ( + "context" + "sync/atomic" "testing" + "time" + "github.com/sipeed/picoclaw/pkg/bus" "github.com/sipeed/picoclaw/pkg/config" runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) @@ -97,3 +101,133 @@ func TestRuntimeEventLogFieldsSummarizeAgentPayload(t *testing.T) { t.Fatalf("raw payload should not be included by runtimeEventLogFields: %#v", fields) } } + +func runtimeEventLoggerStateForTest( + al *AgentLoop, +) (*runtimeEventLogger, runtimeevents.Subscription) { + al.runtimeEventLogMu.RLock() + defer al.runtimeEventLogMu.RUnlock() + return al.runtimeEventLogger, al.runtimeEventLogSub +} + +func TestReloadProviderAndConfigRefreshesRuntimeEventLogger(t *testing.T) { + cfg := config.DefaultConfig() + cfg.Agents.Defaults.Workspace = t.TempDir() + cfg.Events.Logging.Include = []string{"agent.*"} + + al := NewAgentLoop(cfg, bus.NewMessageBus(), &mockProvider{}) + defer al.Close() + + eventLogger, logSub := runtimeEventLoggerStateForTest(al) + if eventLogger == nil || logSub == nil { + t.Fatal("expected initial runtime event logger subscription") + } + if eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindGatewayReloadCompleted, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("initial agent-only logging should not log gateway reload events") + } + + reloaded := config.DefaultConfig() + reloaded.Agents.Defaults.Workspace = cfg.Agents.Defaults.Workspace + reloaded.Events.Logging.Include = []string{"gateway.*"} + if err := al.ReloadProviderAndConfig(context.Background(), &mockProvider{}, reloaded); err != nil { + t.Fatalf("ReloadProviderAndConfig() error = %v", err) + } + + eventLogger, logSub = runtimeEventLoggerStateForTest(al) + if eventLogger == nil || logSub == nil { + t.Fatal("expected runtime event logger subscription after reload") + } + if !eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindGatewayReloadCompleted, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("reloaded gateway logging should log gateway reload events") + } + if eventLogger.shouldLog(runtimeevents.Event{ + Kind: runtimeevents.KindAgentTurnStart, + Severity: runtimeevents.SeverityInfo, + }) { + t.Fatal("reloaded gateway-only logging should not log agent events") + } + + disabled := config.DefaultConfig() + disabled.Agents.Defaults.Workspace = cfg.Agents.Defaults.Workspace + disabled.Events.Logging.Enabled = false + if err := al.ReloadProviderAndConfig(context.Background(), &mockProvider{}, disabled); err != nil { + t.Fatalf("ReloadProviderAndConfig() with disabled logging error = %v", err) + } + eventLogger, logSub = runtimeEventLoggerStateForTest(al) + if eventLogger != nil || logSub != nil { + t.Fatal("expected runtime event logger to be disabled after reload") + } +} + +func TestCloseRuntimeEventLoggerSubscriptionWaitsForDrain(t *testing.T) { + eventBus := runtimeevents.NewBus() + defer func() { + if err := eventBus.Close(); err != nil { + t.Fatalf("Close failed: %v", err) + } + }() + + var handled atomic.Uint64 + firstStarted := make(chan struct{}) + releaseFirst := make(chan struct{}) + sub, err := eventBus.Channel().Subscribe( + context.Background(), + runtimeevents.SubscribeOptions{ + Name: "runtime-event-logger", + Buffer: 2, + Concurrency: runtimeevents.Locked, + }, + func(context.Context, runtimeevents.Event) error { + if handled.Add(1) == 1 { + close(firstStarted) + <-releaseFirst + } + return nil + }, + ) + if err != nil { + t.Fatalf("Subscribe failed: %v", err) + } + + first := eventBus.Publish(context.Background(), runtimeevents.Event{Kind: runtimeevents.Kind("test.first")}) + if first.Delivered != 1 { + t.Fatalf("first Publish = %+v, want one delivered event", first) + } + select { + case <-firstStarted: + case <-time.After(time.Second): + t.Fatal("timed out waiting for first handler to start") + } + second := eventBus.Publish(context.Background(), runtimeevents.Event{Kind: runtimeevents.Kind("test.second")}) + if second.Delivered != 1 { + t.Fatalf("second Publish = %+v, want one delivered event", second) + } + + closeReturned := make(chan struct{}) + go func() { + closeRuntimeEventLoggerSubscription(sub) + close(closeReturned) + }() + + select { + case <-closeReturned: + t.Fatal("runtime event logger close returned before buffered events drained") + case <-time.After(50 * time.Millisecond): + } + + close(releaseFirst) + select { + case <-closeReturned: + case <-time.After(time.Second): + t.Fatal("timed out waiting for runtime event logger close to return") + } + if got := handled.Load(); got != 2 { + t.Fatalf("handled = %d, want 2", got) + } +} diff --git a/pkg/events/subscription.go b/pkg/events/subscription.go index 5ff47eddd..1b3977300 100644 --- a/pkg/events/subscription.go +++ b/pkg/events/subscription.go @@ -102,6 +102,7 @@ type eventSubscription struct { mu sync.RWMutex closed bool wg sync.WaitGroup + blockWG sync.WaitGroup counters subscriberCounters } @@ -278,6 +279,9 @@ func (s *eventSubscription) closeInput() { close(s.closing) s.mu.Lock() s.closed = true + s.mu.Unlock() + s.blockWG.Wait() + s.mu.Lock() close(s.ch) s.mu.Unlock() if s.handler == nil { @@ -304,6 +308,10 @@ func (s *eventSubscription) enqueue(ctx context.Context, evt Event) deliveryResu ctx = context.Background() } + if s.opts.Backpressure == Block { + return s.enqueueBlocking(ctx, evt) + } + s.mu.RLock() defer s.mu.RUnlock() @@ -316,13 +324,25 @@ func (s *eventSubscription) enqueue(ctx context.Context, evt Event) deliveryResu switch s.opts.Backpressure { case DropOldest: return s.enqueueDropOldest(evt) - case Block: - return s.enqueueBlock(ctx, evt) default: return s.enqueueDropNewest(evt) } } +func (s *eventSubscription) enqueueBlocking(ctx context.Context, evt Event) deliveryResult { + s.mu.Lock() + if s.closed { + s.mu.Unlock() + return deliveryResult{closed: true} + } + s.blockWG.Add(1) + s.counters.received.Add(1) + s.mu.Unlock() + + defer s.blockWG.Done() + return s.enqueueBlock(ctx, evt) +} + func (s *eventSubscription) enqueueDropNewest(evt Event) deliveryResult { select { case <-s.closing: diff --git a/pkg/events/subscription_test.go b/pkg/events/subscription_test.go index 8cb5f58dc..44d4be64b 100644 --- a/pkg/events/subscription_test.go +++ b/pkg/events/subscription_test.go @@ -63,6 +63,65 @@ func TestUnsubscribeClosesChannel(t *testing.T) { waitForSubscriptionDone(t, sub) } +func TestBlockBackpressureCloseUnblocksPublisher(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + sub, _, err := bus.Channel().SubscribeChan(context.Background(), SubscribeOptions{ + Name: "block-close", + Buffer: 1, + Backpressure: Block, + }) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + first := bus.Publish(context.Background(), Event{Kind: Kind("test.first")}) + if first.Delivered != 1 { + t.Fatalf("first Publish = %+v, want one delivered event", first) + } + + publishStarted := make(chan struct{}) + publishReturned := make(chan PublishResult, 1) + go func() { + close(publishStarted) + publishReturned <- bus.Publish(context.Background(), Event{Kind: Kind("test.second")}) + }() + + <-publishStarted + waitForStat(t, func() uint64 { + return sub.Stats().Received + }, 2) + select { + case result := <-publishReturned: + t.Fatalf("blocking Publish returned before close: %+v", result) + default: + } + + closeReturned := make(chan error, 1) + go func() { + closeReturned <- sub.Close() + }() + + select { + case err := <-closeReturned: + if err != nil { + t.Fatalf("Close failed: %v", err) + } + case <-time.After(time.Second): + t.Fatal("timed out waiting for Close to unblock") + } + + select { + case <-publishReturned: + case <-time.After(time.Second): + t.Fatal("timed out waiting for blocking Publish to return after close") + } + waitForSubscriptionDone(t, sub) +} + func TestHandlerPanicRecovered(t *testing.T) { t.Parallel() From 1ff8a418f65e36b46c39e3338568ec2e1f0baca7 Mon Sep 17 00:00:00 2001 From: afjcjsbx Date: Sun, 26 Apr 2026 22:23:55 +0200 Subject: [PATCH 26/53] fix(mcp): sanitize MCP tool schemas for Gemini function calling --- pkg/providers/common/google_schema.go | 636 ++++++++++++++++++ pkg/providers/common/google_schema_test.go | 254 +++++++ pkg/providers/httpapi/gemini_helpers.go | 60 -- pkg/providers/httpapi/gemini_provider.go | 2 +- pkg/providers/httpapi/gemini_provider_test.go | 62 ++ pkg/providers/oauth/antigravity_provider.go | 67 +- .../oauth/antigravity_provider_test.go | 72 +- 7 files changed, 1025 insertions(+), 128 deletions(-) create mode 100644 pkg/providers/common/google_schema.go create mode 100644 pkg/providers/common/google_schema_test.go diff --git a/pkg/providers/common/google_schema.go b/pkg/providers/common/google_schema.go new file mode 100644 index 000000000..bdafadd23 --- /dev/null +++ b/pkg/providers/common/google_schema.go @@ -0,0 +1,636 @@ +package common + +import ( + "strconv" + "strings" +) + +const maxGeminiSchemaDepth = 64 + +var geminiSupportedTypes = map[string]bool{ + "array": true, + "boolean": true, + "integer": true, + "number": true, + "object": true, + "string": true, +} + +// SanitizeSchemaForGemini reduces a JSON Schema to the conservative subset +// accepted by Gemini-style function declarations. It resolves local refs, +// collapses composition keywords like anyOf/oneOf/allOf, and strips advanced +// keywords that Gemini rejects. +func SanitizeSchemaForGemini(schema map[string]any) map[string]any { + if schema == nil { + return nil + } + + sanitizer := geminiSchemaSanitizer{root: schema} + result := sanitizer.sanitizeNode(schema, nil, 0) + if len(result) == 0 { + return map[string]any{ + "type": "object", + "properties": map[string]any{}, + } + } + if _, hasProps := result["properties"]; hasProps { + result["type"] = "object" + } + return result +} + +type geminiSchemaSanitizer struct { + root map[string]any +} + +func (s geminiSchemaSanitizer) sanitizeNode( + node map[string]any, + refTrail map[string]struct{}, + depth int, +) map[string]any { + if node == nil || depth > maxGeminiSchemaDepth { + return map[string]any{} + } + + normalized := s.normalizeNode(node, refTrail, depth) + if len(normalized) == 0 { + return map[string]any{} + } + + result := make(map[string]any) + + if desc, ok := normalized["description"].(string); ok && strings.TrimSpace(desc) != "" { + result["description"] = desc + } + + if schemaType := sanitizeGeminiSchemaType(normalized["type"]); schemaType != "" { + result["type"] = schemaType + } + + if enumValues := sanitizeGeminiEnum(normalized["enum"]); len(enumValues) > 0 { + result["enum"] = enumValues + } + + if propsRaw, ok := normalized["properties"].(map[string]any); ok { + props := make(map[string]any, len(propsRaw)) + for name, rawProp := range propsRaw { + propSchema, ok := rawProp.(map[string]any) + if !ok { + continue + } + sanitizedProp := s.sanitizeNode(propSchema, refTrail, depth+1) + if len(sanitizedProp) == 0 { + sanitizedProp = map[string]any{} + } + props[name] = sanitizedProp + } + result["properties"] = props + result["type"] = "object" + if required := sanitizeGeminiRequired(normalized["required"], props); len(required) > 0 { + result["required"] = required + } + } + + if itemsRaw, ok := normalized["items"].(map[string]any); ok { + items := s.sanitizeNode(itemsRaw, refTrail, depth+1) + if len(items) == 0 { + items = map[string]any{} + } + result["items"] = items + if _, hasType := result["type"]; !hasType { + result["type"] = "array" + } + } + + return result +} + +func (s geminiSchemaSanitizer) normalizeNode( + node map[string]any, + refTrail map[string]struct{}, + depth int, +) map[string]any { + if node == nil || depth > maxGeminiSchemaDepth { + return map[string]any{} + } + + normalized := cloneGeminiSchemaMap(node) + + if ref, ok := normalized["$ref"].(string); ok { + delete(normalized, "$ref") + if _, seen := refTrail[ref]; !seen { + if target, ok := s.resolveLocalSchemaRef(ref); ok { + nextTrail := cloneRefTrail(refTrail) + nextTrail[ref] = struct{}{} + normalized = mergeGeminiSchemaMaps( + s.normalizeNode(target, nextTrail, depth+1), + normalized, + ) + } + } + } + + if rawAllOf, ok := normalized["allOf"]; ok { + delete(normalized, "allOf") + for _, part := range schemaSlice(rawAllOf) { + normalized = mergeGeminiSchemaMaps( + normalized, + s.normalizeNode(part, refTrail, depth+1), + ) + } + } + + if rawAnyOf, ok := normalized["anyOf"]; ok { + delete(normalized, "anyOf") + normalized = mergeGeminiSchemaMaps( + s.mergeUnionBranches(schemaSlice(rawAnyOf), refTrail, depth+1), + normalized, + ) + } + + if rawOneOf, ok := normalized["oneOf"]; ok { + delete(normalized, "oneOf") + normalized = mergeGeminiSchemaMaps( + s.mergeUnionBranches(schemaSlice(rawOneOf), refTrail, depth+1), + normalized, + ) + } + + return normalized +} + +func (s geminiSchemaSanitizer) mergeUnionBranches( + branches []map[string]any, + refTrail map[string]struct{}, + depth int, +) map[string]any { + if len(branches) == 0 { + return map[string]any{} + } + + objectBranches := make([]map[string]any, 0, len(branches)) + arrayBranches := make([]map[string]any, 0, len(branches)) + nonNullBranches := make([]map[string]any, 0, len(branches)) + sameType := "" + sameTypeConsistent := true + + for _, branch := range branches { + normalized := s.normalizeNode(branch, refTrail, depth+1) + if len(normalized) == 0 { + continue + } + + branchType := geminiSchemaBranchType(normalized["type"]) + if branchType == "null" { + continue + } + nonNullBranches = append(nonNullBranches, normalized) + + if sameType == "" { + sameType = branchType + } else if branchType != "" && branchType != sameType { + sameTypeConsistent = false + } + + if branchType == "object" || hasSchemaProperties(normalized) { + objectBranches = append(objectBranches, normalized) + continue + } + if branchType == "array" || hasSchemaItems(normalized) { + arrayBranches = append(arrayBranches, normalized) + } + } + + if len(nonNullBranches) == 0 { + return map[string]any{} + } + if len(objectBranches) > 0 { + return mergeUnionObjectSchemas(objectBranches) + } + if len(arrayBranches) == len(nonNullBranches) && len(arrayBranches) > 0 { + return mergeUnionArraySchemas(arrayBranches) + } + if sameTypeConsistent && sameType != "" { + merged := map[string]any{} + for _, branch := range nonNullBranches { + merged = mergeGeminiSchemaMaps(merged, branch) + } + return merged + } + + best := nonNullBranches[0] + bestScore := geminiUnionBranchScore(best) + for _, branch := range nonNullBranches[1:] { + if score := geminiUnionBranchScore(branch); score > bestScore { + best = branch + bestScore = score + } + } + return cloneGeminiSchemaMap(best) +} + +func (s geminiSchemaSanitizer) resolveLocalSchemaRef(ref string) (map[string]any, bool) { + if ref == "#" { + return s.root, true + } + if !strings.HasPrefix(ref, "#/") { + return nil, false + } + + var current any = s.root + for _, rawToken := range strings.Split(strings.TrimPrefix(ref, "#/"), "/") { + token := strings.ReplaceAll(strings.ReplaceAll(rawToken, "~1", "/"), "~0", "~") + switch value := current.(type) { + case map[string]any: + next, ok := value[token] + if !ok { + return nil, false + } + current = next + case []any: + index, err := strconv.Atoi(token) + if err != nil || index < 0 || index >= len(value) { + return nil, false + } + current = value[index] + default: + return nil, false + } + } + + resolved, ok := current.(map[string]any) + return resolved, ok +} + +func mergeUnionObjectSchemas(branches []map[string]any) map[string]any { + merged := map[string]any{ + "type": "object", + "properties": map[string]any{}, + } + + var commonRequired map[string]struct{} + var requiredOrder []string + + for i, branch := range branches { + merged = mergeGeminiSchemaMaps(merged, branch) + + required := requiredStrings(branch["required"]) + if i == 0 { + commonRequired = make(map[string]struct{}, len(required)) + requiredOrder = append(requiredOrder, required...) + for _, name := range required { + commonRequired[name] = struct{}{} + } + continue + } + + current := make(map[string]struct{}, len(required)) + for _, name := range required { + current[name] = struct{}{} + } + for name := range commonRequired { + if _, ok := current[name]; !ok { + delete(commonRequired, name) + } + } + } + + if len(commonRequired) > 0 { + filtered := make([]string, 0, len(commonRequired)) + for _, name := range requiredOrder { + if _, ok := commonRequired[name]; ok { + filtered = append(filtered, name) + } + } + if len(filtered) > 0 { + merged["required"] = filtered + } + } else { + delete(merged, "required") + } + + return merged +} + +func mergeUnionArraySchemas(branches []map[string]any) map[string]any { + merged := map[string]any{ + "type": "array", + } + for _, branch := range branches { + merged = mergeGeminiSchemaMaps(merged, branch) + } + return merged +} + +func mergeGeminiSchemaMaps(base map[string]any, overlay map[string]any) map[string]any { + if len(base) == 0 { + return cloneGeminiSchemaMap(overlay) + } + if len(overlay) == 0 { + return cloneGeminiSchemaMap(base) + } + + result := cloneGeminiSchemaMap(base) + for key, value := range overlay { + switch key { + case "properties": + overlayProps, ok := value.(map[string]any) + if !ok { + continue + } + existing, _ := result["properties"].(map[string]any) + mergedProps := cloneGeminiSchemaMap(existing) + if mergedProps == nil { + mergedProps = make(map[string]any, len(overlayProps)) + } + for name, rawProp := range overlayProps { + propSchema, ok := rawProp.(map[string]any) + if !ok { + continue + } + if existingProp, ok := mergedProps[name].(map[string]any); ok { + mergedProps[name] = mergeGeminiSchemaMaps(existingProp, propSchema) + } else { + mergedProps[name] = cloneGeminiSchemaMap(propSchema) + } + } + result["properties"] = mergedProps + case "items": + overlayItems, ok := value.(map[string]any) + if !ok { + continue + } + if existingItems, ok := result["items"].(map[string]any); ok { + result["items"] = mergeGeminiSchemaMaps(existingItems, overlayItems) + } else { + result["items"] = cloneGeminiSchemaMap(overlayItems) + } + case "required": + if merged := mergeRequiredLists(result["required"], value); len(merged) > 0 { + result["required"] = merged + } + case "type": + if mergedType := mergeGeminiSchemaTypes(result["type"], value); mergedType != "" { + result["type"] = mergedType + } else { + delete(result, "type") + } + case "description": + desc, ok := value.(string) + if ok && strings.TrimSpace(desc) != "" { + result["description"] = desc + } + default: + result[key] = cloneGeminiSchemaValue(value) + } + } + + return result +} + +func mergeGeminiSchemaTypes(left any, right any) string { + leftType := geminiSchemaBranchType(left) + rightType := geminiSchemaBranchType(right) + + switch { + case leftType == "": + return rightType + case rightType == "": + return leftType + case leftType == rightType: + return leftType + case leftType == "null": + return rightType + case rightType == "null": + return leftType + default: + return "" + } +} + +func sanitizeGeminiSchemaType(raw any) string { + typeName := geminiSchemaBranchType(raw) + if typeName == "null" { + return "" + } + return typeName +} + +func geminiSchemaBranchType(raw any) string { + switch value := raw.(type) { + case string: + if value == "null" { + return value + } + if geminiSupportedTypes[value] { + return value + } + return "" + case []string: + return geminiSchemaBranchType(stringSliceToAny(value)) + case []any: + candidate := "" + sawNull := false + for _, item := range value { + typeName, ok := item.(string) + if !ok { + continue + } + if typeName == "null" { + sawNull = true + continue + } + if !geminiSupportedTypes[typeName] { + continue + } + if candidate == "" { + candidate = typeName + continue + } + if candidate != typeName { + return "" + } + } + if candidate == "" && sawNull { + return "null" + } + return candidate + default: + return "" + } +} + +func sanitizeGeminiEnum(raw any) []any { + values, ok := raw.([]any) + if !ok { + if stringValues, ok := raw.([]string); ok { + return stringSliceToAny(stringValues) + } + return nil + } + + sanitized := make([]any, 0, len(values)) + for _, value := range values { + switch value.(type) { + case string, bool, float64, int, int32, int64: + sanitized = append(sanitized, value) + } + } + if len(sanitized) == 0 { + return nil + } + return sanitized +} + +func sanitizeGeminiRequired(raw any, properties map[string]any) []string { + required := requiredStrings(raw) + if len(required) == 0 { + return nil + } + + filtered := make([]string, 0, len(required)) + seen := make(map[string]struct{}, len(required)) + for _, name := range required { + if _, ok := properties[name]; !ok { + continue + } + if _, ok := seen[name]; ok { + continue + } + seen[name] = struct{}{} + filtered = append(filtered, name) + } + if len(filtered) == 0 { + return nil + } + return filtered +} + +func requiredStrings(raw any) []string { + switch value := raw.(type) { + case []string: + return append([]string(nil), value...) + case []any: + required := make([]string, 0, len(value)) + for _, item := range value { + name, ok := item.(string) + if ok { + required = append(required, name) + } + } + return required + default: + return nil + } +} + +func mergeRequiredLists(left any, right any) []string { + merged := make([]string, 0) + seen := map[string]struct{}{} + + for _, name := range append(requiredStrings(left), requiredStrings(right)...) { + if _, ok := seen[name]; ok { + continue + } + seen[name] = struct{}{} + merged = append(merged, name) + } + + return merged +} + +func geminiUnionBranchScore(schema map[string]any) int { + score := 0 + if hasSchemaProperties(schema) { + score += 20 + } + if hasSchemaItems(schema) { + score += 10 + } + if _, ok := schema["enum"]; ok { + score += 5 + } + if _, ok := schema["description"]; ok { + score += 2 + } + score += len(schema) + return score +} + +func hasSchemaProperties(schema map[string]any) bool { + props, ok := schema["properties"].(map[string]any) + return ok && len(props) > 0 +} + +func hasSchemaItems(schema map[string]any) bool { + _, ok := schema["items"].(map[string]any) + return ok +} + +func schemaSlice(raw any) []map[string]any { + switch value := raw.(type) { + case []map[string]any: + return append([]map[string]any(nil), value...) + case []any: + schemas := make([]map[string]any, 0, len(value)) + for _, item := range value { + schema, ok := item.(map[string]any) + if ok { + schemas = append(schemas, schema) + } + } + return schemas + default: + return nil + } +} + +func cloneGeminiSchemaMap(in map[string]any) map[string]any { + if len(in) == 0 { + return nil + } + out := make(map[string]any, len(in)) + for key, value := range in { + out[key] = cloneGeminiSchemaValue(value) + } + return out +} + +func cloneGeminiSchemaValue(value any) any { + switch typed := value.(type) { + case map[string]any: + return cloneGeminiSchemaMap(typed) + case []any: + out := make([]any, len(typed)) + for i, item := range typed { + out[i] = cloneGeminiSchemaValue(item) + } + return out + case []string: + return append([]string(nil), typed...) + default: + return typed + } +} + +func cloneRefTrail(in map[string]struct{}) map[string]struct{} { + if len(in) == 0 { + return make(map[string]struct{}) + } + out := make(map[string]struct{}, len(in)) + for key := range in { + out[key] = struct{}{} + } + return out +} + +func stringSliceToAny(values []string) []any { + if len(values) == 0 { + return nil + } + result := make([]any, len(values)) + for i, value := range values { + result[i] = value + } + return result +} diff --git a/pkg/providers/common/google_schema_test.go b/pkg/providers/common/google_schema_test.go new file mode 100644 index 000000000..af2520493 --- /dev/null +++ b/pkg/providers/common/google_schema_test.go @@ -0,0 +1,254 @@ +package common + +import "testing" + +func TestSanitizeSchemaForGemini_DereferencesRefsAndFlattensUnions(t *testing.T) { + schema := map[string]any{ + "type": "object", + "properties": map[string]any{ + "parent": map[string]any{ + "anyOf": []any{ + map[string]any{"$ref": "#/$defs/pageParent"}, + map[string]any{"$ref": "#/$defs/databaseParent"}, + }, + }, + "icon": map[string]any{ + "anyOf": []any{ + map[string]any{"$ref": "#/$defs/emoji"}, + map[string]any{"type": "null"}, + }, + }, + "data": map[string]any{ + "$ref": "#/$defs/dataPayload", + }, + }, + "required": []any{"parent", "icon", "missing"}, + "$defs": map[string]any{ + "pageParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "page_id": map[string]any{ + "type": "string", + }, + }, + "required": []any{"page_id"}, + }, + "databaseParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "database_id": map[string]any{ + "type": "string", + }, + }, + "required": []any{"database_id"}, + }, + "emoji": map[string]any{ + "type": "string", + "pattern": "^:[a-z_]+:$", + }, + "dataPayload": map[string]any{ + "type": "object", + "additionalProperties": false, + "properties": map[string]any{ + "name": map[string]any{ + "type": "string", + "minLength": 1, + }, + "count": map[string]any{ + "type": "integer", + "minimum": 1, + }, + }, + "required": []any{"name"}, + }, + }, + } + + got := SanitizeSchemaForGemini(schema) + assertSchemaKeyAbsent(t, got, "$defs") + assertSchemaKeyAbsent(t, got, "$ref") + assertSchemaKeyAbsent(t, got, "anyOf") + assertSchemaKeyAbsent(t, got, "oneOf") + assertSchemaKeyAbsent(t, got, "allOf") + assertSchemaKeyAbsent(t, got, "additionalProperties") + assertSchemaKeyAbsent(t, got, "pattern") + assertSchemaKeyAbsent(t, got, "minLength") + assertSchemaKeyAbsent(t, got, "minimum") + + if got["type"] != "object" { + t.Fatalf("top-level type = %#v, want object", got["type"]) + } + + props, ok := got["properties"].(map[string]any) + if !ok { + t.Fatalf("properties = %#v, want map", got["properties"]) + } + + parent, ok := props["parent"].(map[string]any) + if !ok { + t.Fatalf("parent schema = %#v, want map", props["parent"]) + } + if parent["type"] != "object" { + t.Fatalf("parent.type = %#v, want object", parent["type"]) + } + parentProps, ok := parent["properties"].(map[string]any) + if !ok { + t.Fatalf("parent.properties = %#v, want map", parent["properties"]) + } + if _, ok := parentProps["page_id"]; !ok { + t.Fatalf("parent.properties missing page_id: %#v", parentProps) + } + if _, ok := parentProps["database_id"]; !ok { + t.Fatalf("parent.properties missing database_id: %#v", parentProps) + } + if _, hasRequired := parent["required"]; hasRequired { + t.Fatalf("parent.required = %#v, want omitted for merged anyOf branches", parent["required"]) + } + + icon, ok := props["icon"].(map[string]any) + if !ok { + t.Fatalf("icon schema = %#v, want map", props["icon"]) + } + if icon["type"] != "string" { + t.Fatalf("icon.type = %#v, want string", icon["type"]) + } + + data, ok := props["data"].(map[string]any) + if !ok { + t.Fatalf("data schema = %#v, want map", props["data"]) + } + if data["type"] != "object" { + t.Fatalf("data.type = %#v, want object", data["type"]) + } + dataProps, ok := data["properties"].(map[string]any) + if !ok { + t.Fatalf("data.properties = %#v, want map", data["properties"]) + } + if _, ok := dataProps["name"]; !ok { + t.Fatalf("data.properties missing name: %#v", dataProps) + } + if _, ok := dataProps["count"]; !ok { + t.Fatalf("data.properties missing count: %#v", dataProps) + } + + required, ok := got["required"].([]string) + if !ok { + t.Fatalf("required = %#v, want []string", got["required"]) + } + if len(required) != 2 || required[0] != "parent" || required[1] != "icon" { + t.Fatalf("required = %#v, want [parent icon]", required) + } +} + +func TestSanitizeSchemaForGemini_MergesAllOfAndFiltersRequired(t *testing.T) { + schema := map[string]any{ + "type": "object", + "properties": map[string]any{ + "payload": map[string]any{ + "allOf": []any{ + map[string]any{ + "type": "object", + "properties": map[string]any{ + "id": map[string]any{ + "type": "string", + }, + }, + "required": []any{"id"}, + }, + map[string]any{ + "properties": map[string]any{ + "name": map[string]any{ + "type": "string", + }, + "count": map[string]any{ + "type": "integer", + "minimum": 1, + }, + }, + "required": []any{"name", "missing"}, + }, + }, + }, + }, + } + + got := SanitizeSchemaForGemini(schema) + props := got["properties"].(map[string]any) + payload := props["payload"].(map[string]any) + + if payload["type"] != "object" { + t.Fatalf("payload.type = %#v, want object", payload["type"]) + } + payloadProps, ok := payload["properties"].(map[string]any) + if !ok { + t.Fatalf("payload.properties = %#v, want map", payload["properties"]) + } + for _, key := range []string{"id", "name", "count"} { + if _, ok := payloadProps[key]; !ok { + t.Fatalf("payload.properties missing %q: %#v", key, payloadProps) + } + } + + required, ok := payload["required"].([]string) + if !ok { + t.Fatalf("payload.required = %#v, want []string", payload["required"]) + } + if len(required) != 2 || required[0] != "id" || required[1] != "name" { + t.Fatalf("payload.required = %#v, want [id name]", required) + } + + assertSchemaKeyAbsent(t, payload, "allOf") + assertSchemaKeyAbsent(t, payload, "minimum") +} + +func TestSanitizeSchemaForGemini_HandlesRecursiveRefs(t *testing.T) { + schema := map[string]any{ + "type": "object", + "properties": map[string]any{ + "tree": map[string]any{ + "$ref": "#/$defs/node", + }, + }, + "$defs": map[string]any{ + "node": map[string]any{ + "type": "object", + "properties": map[string]any{ + "name": map[string]any{ + "type": "string", + }, + "child": map[string]any{ + "$ref": "#/$defs/node", + }, + }, + }, + }, + } + + got := SanitizeSchemaForGemini(schema) + props := got["properties"].(map[string]any) + tree := props["tree"].(map[string]any) + if tree["type"] != "object" { + t.Fatalf("tree.type = %#v, want object", tree["type"]) + } + assertSchemaKeyAbsent(t, tree, "$ref") +} + +func assertSchemaKeyAbsent(t *testing.T, value any, key string) { + t.Helper() + + switch typed := value.(type) { + case map[string]any: + if _, found := typed[key]; found { + t.Fatalf("schema still contains key %q: %#v", key, typed) + } + for _, nested := range typed { + assertSchemaKeyAbsent(t, nested, key) + } + case []any: + for _, nested := range typed { + assertSchemaKeyAbsent(t, nested, key) + } + case []string: + return + } +} diff --git a/pkg/providers/httpapi/gemini_helpers.go b/pkg/providers/httpapi/gemini_helpers.go index a2b2d63c3..87cc4c084 100644 --- a/pkg/providers/httpapi/gemini_helpers.go +++ b/pkg/providers/httpapi/gemini_helpers.go @@ -12,66 +12,6 @@ func extractPartThoughtSignature(thoughtSignature string, thoughtSignatureSnake return "" } -var geminiUnsupportedKeywords = map[string]bool{ - "patternProperties": true, - "additionalProperties": true, - "$schema": true, - "$id": true, - "$ref": true, - "$defs": true, - "definitions": true, - "examples": true, - "minLength": true, - "maxLength": true, - "minimum": true, - "maximum": true, - "multipleOf": true, - "pattern": true, - "format": true, - "minItems": true, - "maxItems": true, - "uniqueItems": true, - "minProperties": true, - "maxProperties": true, -} - -func sanitizeSchemaForGemini(schema map[string]any) map[string]any { - if schema == nil { - return nil - } - - result := make(map[string]any) - for k, v := range schema { - if geminiUnsupportedKeywords[k] { - continue - } - switch val := v.(type) { - case map[string]any: - result[k] = sanitizeSchemaForGemini(val) - case []any: - sanitized := make([]any, len(val)) - for i, item := range val { - if m, ok := item.(map[string]any); ok { - sanitized[i] = sanitizeSchemaForGemini(m) - } else { - sanitized[i] = item - } - } - result[k] = sanitized - default: - result[k] = v - } - } - - if _, hasProps := result["properties"]; hasProps { - if _, hasType := result["type"]; !hasType { - result["type"] = "object" - } - } - - return result -} - func extractProtocol(model string) (protocol, modelID string) { model = strings.TrimSpace(model) protocol, modelID, found := strings.Cut(model, "/") diff --git a/pkg/providers/httpapi/gemini_provider.go b/pkg/providers/httpapi/gemini_provider.go index d1d523757..e73568c88 100644 --- a/pkg/providers/httpapi/gemini_provider.go +++ b/pkg/providers/httpapi/gemini_provider.go @@ -264,7 +264,7 @@ func (p *GeminiProvider) buildRequestBody( funcDecls = append(funcDecls, geminiFunctionDeclaration{ Name: t.Function.Name, Description: t.Function.Description, - Parameters: sanitizeSchemaForGemini(t.Function.Parameters), + Parameters: common.SanitizeSchemaForGemini(t.Function.Parameters), }) } if len(funcDecls) > 0 { diff --git a/pkg/providers/httpapi/gemini_provider_test.go b/pkg/providers/httpapi/gemini_provider_test.go index aade90358..53770511e 100644 --- a/pkg/providers/httpapi/gemini_provider_test.go +++ b/pkg/providers/httpapi/gemini_provider_test.go @@ -5,8 +5,11 @@ import ( "fmt" "net/http" "net/http/httptest" + "reflect" "strings" "testing" + + providercommon "github.com/sipeed/picoclaw/pkg/providers/common" ) func TestGeminiProvider_ChatSeparatesThoughtAndToolCall(t *testing.T) { @@ -259,6 +262,65 @@ func TestGeminiProvider_ChatStreamSkipsEmptyDataFrames(t *testing.T) { } } +func TestGeminiProvider_BuildRequestBody_SanitizesComplexToolSchemas(t *testing.T) { + provider := NewGeminiProvider("test-key", "https://example.com/v1beta", "", "", 0, nil, nil) + schema := map[string]any{ + "type": "object", + "properties": map[string]any{ + "parent": map[string]any{ + "anyOf": []any{ + map[string]any{"$ref": "#/$defs/pageParent"}, + map[string]any{"$ref": "#/$defs/databaseParent"}, + }, + }, + }, + "$defs": map[string]any{ + "pageParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "page_id": map[string]any{"type": "string"}, + }, + "required": []any{"page_id"}, + }, + "databaseParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "database_id": map[string]any{"type": "string"}, + }, + "required": []any{"database_id"}, + }, + }, + } + + body := provider.buildRequestBody( + []Message{{Role: "user", Content: "hello"}}, + []ToolDefinition{{ + Type: "function", + Function: ToolFunctionDefinition{ + Name: "mcp_notion_create", + Description: "Create a Notion object", + Parameters: schema, + }, + }}, + "gemini-3-flash-preview", + nil, + ) + + tools, ok := body["tools"].([]geminiTool) + if !ok || len(tools) != 1 { + t.Fatalf("tools = %#v, want one geminiTool", body["tools"]) + } + got, ok := tools[0].FunctionDeclarations[0].Parameters.(map[string]any) + if !ok { + t.Fatalf("parameters = %#v, want map", tools[0].FunctionDeclarations[0].Parameters) + } + + want := providercommon.SanitizeSchemaForGemini(schema) + if !reflect.DeepEqual(got, want) { + t.Fatalf("sanitized parameters mismatch\n got: %#v\nwant: %#v", got, want) + } +} + func TestGeminiProvider_ChatStreamReturnsErrorOnInvalidDataFrame(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") diff --git a/pkg/providers/oauth/antigravity_provider.go b/pkg/providers/oauth/antigravity_provider.go index 1ac2d9c7f..fd5431b03 100644 --- a/pkg/providers/oauth/antigravity_provider.go +++ b/pkg/providers/oauth/antigravity_provider.go @@ -298,7 +298,7 @@ func (p *AntigravityProvider) buildRequest( if t.Type != "function" { continue } - params := sanitizeSchemaForGemini(t.Function.Parameters) + params := common.SanitizeSchemaForGemini(t.Function.Parameters) funcDecls = append(funcDecls, antigravityFuncDecl{ Name: t.Function.Name, Description: t.Function.Description, @@ -446,71 +446,6 @@ func extractPartThoughtSignature(thoughtSignature string, thoughtSignatureSnake return "" } -// --- Schema sanitization --- - -// Google/Gemini doesn't support many JSON Schema keywords that other providers accept. -var geminiUnsupportedKeywords = map[string]bool{ - "patternProperties": true, - "additionalProperties": true, - "$schema": true, - "$id": true, - "$ref": true, - "$defs": true, - "definitions": true, - "examples": true, - "minLength": true, - "maxLength": true, - "minimum": true, - "maximum": true, - "multipleOf": true, - "pattern": true, - "format": true, - "minItems": true, - "maxItems": true, - "uniqueItems": true, - "minProperties": true, - "maxProperties": true, -} - -func sanitizeSchemaForGemini(schema map[string]any) map[string]any { - if schema == nil { - return nil - } - - result := make(map[string]any) - for k, v := range schema { - if geminiUnsupportedKeywords[k] { - continue - } - // Recursively sanitize nested objects - switch val := v.(type) { - case map[string]any: - result[k] = sanitizeSchemaForGemini(val) - case []any: - sanitized := make([]any, len(val)) - for i, item := range val { - if m, ok := item.(map[string]any); ok { - sanitized[i] = sanitizeSchemaForGemini(m) - } else { - sanitized[i] = item - } - } - result[k] = sanitized - default: - result[k] = v - } - } - - // Ensure top-level has type: "object" if properties are present - if _, hasProps := result["properties"]; hasProps { - if _, hasType := result["type"]; !hasType { - result["type"] = "object" - } - } - - return result -} - // --- Token source --- func createAntigravityTokenSource() func() (string, string, error) { diff --git a/pkg/providers/oauth/antigravity_provider_test.go b/pkg/providers/oauth/antigravity_provider_test.go index 2989f8519..015b1ab80 100644 --- a/pkg/providers/oauth/antigravity_provider_test.go +++ b/pkg/providers/oauth/antigravity_provider_test.go @@ -1,6 +1,11 @@ package oauthprovider -import "testing" +import ( + "reflect" + "testing" + + providercommon "github.com/sipeed/picoclaw/pkg/providers/common" +) func TestBuildRequestUsesFunctionFieldsWhenToolCallNameMissing(t *testing.T) { p := &AntigravityProvider{} @@ -71,3 +76,68 @@ func TestParseSSEResponse_SplitsThoughtAndVisibleContent(t *testing.T) { t.Fatalf("Usage.TotalTokens = %v, want %d", resp.Usage, 216) } } + +func TestBuildRequest_SanitizesComplexToolSchemas(t *testing.T) { + p := &AntigravityProvider{} + schema := map[string]any{ + "type": "object", + "properties": map[string]any{ + "parent": map[string]any{ + "anyOf": []any{ + map[string]any{"$ref": "#/$defs/pageParent"}, + map[string]any{"$ref": "#/$defs/databaseParent"}, + }, + }, + "icon": map[string]any{ + "anyOf": []any{ + map[string]any{"type": "null"}, + map[string]any{"$ref": "#/$defs/emoji"}, + }, + }, + }, + "$defs": map[string]any{ + "pageParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "page_id": map[string]any{"type": "string"}, + }, + "required": []any{"page_id"}, + }, + "databaseParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "database_id": map[string]any{"type": "string"}, + }, + "required": []any{"database_id"}, + }, + "emoji": map[string]any{ + "type": "string", + "pattern": "^:[a-z_]+:$", + }, + }, + } + + req := p.buildRequest( + []Message{{Role: "user", Content: "hello"}}, + []ToolDefinition{{ + Type: "function", + Function: ToolFunctionDefinition{ + Name: "mcp_notion_create", + Description: "Create a Notion object", + Parameters: schema, + }, + }}, + "gemini-3-flash", + nil, + ) + + if len(req.Tools) != 1 || len(req.Tools[0].FunctionDeclarations) != 1 { + t.Fatalf("request tools = %#v, want one function declaration", req.Tools) + } + + got := req.Tools[0].FunctionDeclarations[0].Parameters + want := providercommon.SanitizeSchemaForGemini(schema) + if !reflect.DeepEqual(got, want) { + t.Fatalf("sanitized parameters mismatch\n got: %#v\nwant: %#v", got, want) + } +} From 4eeb69688e6dffbb4e26c3ca015ce51ee7a0c145 Mon Sep 17 00:00:00 2001 From: afjcjsbx Date: Sun, 26 Apr 2026 22:33:35 +0200 Subject: [PATCH 27/53] fix lint --- pkg/providers/common/google_schema_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pkg/providers/common/google_schema_test.go b/pkg/providers/common/google_schema_test.go index af2520493..23aadbf98 100644 --- a/pkg/providers/common/google_schema_test.go +++ b/pkg/providers/common/google_schema_test.go @@ -95,10 +95,10 @@ func TestSanitizeSchemaForGemini_DereferencesRefsAndFlattensUnions(t *testing.T) if !ok { t.Fatalf("parent.properties = %#v, want map", parent["properties"]) } - if _, ok := parentProps["page_id"]; !ok { + if _, found := parentProps["page_id"]; !found { t.Fatalf("parent.properties missing page_id: %#v", parentProps) } - if _, ok := parentProps["database_id"]; !ok { + if _, found := parentProps["database_id"]; !found { t.Fatalf("parent.properties missing database_id: %#v", parentProps) } if _, hasRequired := parent["required"]; hasRequired { @@ -124,10 +124,10 @@ func TestSanitizeSchemaForGemini_DereferencesRefsAndFlattensUnions(t *testing.T) if !ok { t.Fatalf("data.properties = %#v, want map", data["properties"]) } - if _, ok := dataProps["name"]; !ok { + if _, found := dataProps["name"]; !found { t.Fatalf("data.properties missing name: %#v", dataProps) } - if _, ok := dataProps["count"]; !ok { + if _, found := dataProps["count"]; !found { t.Fatalf("data.properties missing count: %#v", dataProps) } @@ -184,7 +184,7 @@ func TestSanitizeSchemaForGemini_MergesAllOfAndFiltersRequired(t *testing.T) { t.Fatalf("payload.properties = %#v, want map", payload["properties"]) } for _, key := range []string{"id", "name", "count"} { - if _, ok := payloadProps[key]; !ok { + if _, found := payloadProps[key]; !found { t.Fatalf("payload.properties missing %q: %#v", key, payloadProps) } } From f62e8621fc14200e23bf06871a295e3ac50c34dc Mon Sep 17 00:00:00 2001 From: dtapps Date: Mon, 27 Apr 2026 09:30:11 +0800 Subject: [PATCH 28/53] docs: fix agents.defaults model configuration format Change incorrect object format model.primary/fallbacks to correct flat format model_name/model_fallbacks in Agent defaults example. The AgentDefaults struct does not support the object format used in AgentConfig, so the documentation example was misleading. --- docs/guides/providers.md | 6 ++---- docs/guides/providers.zh.md | 6 ++---- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/docs/guides/providers.md b/docs/guides/providers.md index d99d8c016..4e1f472d5 100644 --- a/docs/guides/providers.md +++ b/docs/guides/providers.md @@ -393,10 +393,8 @@ It also applies cooldown tracking per candidate to avoid immediately retrying a ], "agents": { "defaults": { - "model": { - "primary": "qwen-main", - "fallbacks": ["deepseek-backup", "gemini-backup"] - } + "model_name": "qwen-main", + "model_fallbacks": ["deepseek-backup", "gemini-backup"] } } } diff --git a/docs/guides/providers.zh.md b/docs/guides/providers.zh.md index 1302407a3..4bab65f6b 100644 --- a/docs/guides/providers.zh.md +++ b/docs/guides/providers.zh.md @@ -362,10 +362,8 @@ PicoClaw 按下面的规则解析 `provider` 和最终发给上游的模型 ID ], "agents": { "defaults": { - "model": { - "primary": "qwen-main", - "fallbacks": ["deepseek-backup", "gemini-backup"] - } + "model_name": "qwen-main", + "model_fallbacks": ["deepseek-backup", "gemini-backup"] } } } From 78fd080189cdaab14861a41273fc5e0cc6d1cf43 Mon Sep 17 00:00:00 2001 From: Hoshina Date: Mon, 27 Apr 2026 13:09:03 +0800 Subject: [PATCH 29/53] fix(events): keep runtime observers non-blocking Add a non-blocking runtime publish path and switch hot-path publishers to it. Enforce subscription timeout boundaries, keep ordered subscriber snapshots up to date on subscribe changes, expose all runtime kinds to process hooks, add safe log attrs for non-agent events, and close the gateway message bus on full shutdown. --- pkg/agent/events_runtime.go | 14 +--- pkg/agent/hook_mount.go | 22 +----- pkg/agent/hook_mount_test.go | 4 +- pkg/agent/runtime_event_logger_test.go | 26 +++++++ pkg/bus/bus.go | 1 + pkg/bus/bus_test.go | 10 +++ pkg/bus/events.go | 22 +++--- pkg/channels/events.go | 45 +++++++++--- pkg/channels/manager_test.go | 6 ++ pkg/events/bus.go | 42 ++++++----- pkg/events/events_test.go | 99 ++++++++++++++++++++++++++ pkg/events/kind.go | 53 ++++++++++++++ pkg/events/subscription.go | 73 ++++++++++++++++--- pkg/events/subscription_test.go | 39 ++++++++++ pkg/gateway/events.go | 19 +++-- pkg/gateway/gateway.go | 7 +- pkg/gateway/gateway_test.go | 37 ++++++++++ pkg/mcp/events.go | 33 ++++++--- pkg/mcp/manager_test.go | 8 +++ pkg/tools/integration/mcp_tool.go | 20 +++++- pkg/tools/integration/mcp_tool_test.go | 5 ++ 21 files changed, 486 insertions(+), 99 deletions(-) diff --git a/pkg/agent/events_runtime.go b/pkg/agent/events_runtime.go index b530f6161..2284665e6 100644 --- a/pkg/agent/events_runtime.go +++ b/pkg/agent/events_runtime.go @@ -1,23 +1,13 @@ package agent -import ( - "context" - "time" - - runtimeevents "github.com/sipeed/picoclaw/pkg/events" -) - -const runtimeEventPublishTimeout = 100 * time.Millisecond +import runtimeevents "github.com/sipeed/picoclaw/pkg/events" func (al *AgentLoop) publishRuntimeEvent(evt runtimeevents.Event) { if al == nil || al.runtimeEvents == nil { return } - ctx, cancel := context.WithTimeout(context.Background(), runtimeEventPublishTimeout) - defer cancel() - - al.runtimeEvents.Publish(ctx, evt) + al.runtimeEvents.PublishNonBlocking(evt) } func runtimeScopeFromHookMeta(meta HookMeta, eventCtx *TurnContext) runtimeevents.Scope { diff --git a/pkg/agent/hook_mount.go b/pkg/agent/hook_mount.go index 409d56b32..c518feee8 100644 --- a/pkg/agent/hook_mount.go +++ b/pkg/agent/hook_mount.go @@ -311,27 +311,7 @@ func processHookObserveKindsFromConfig(observe []string) ([]string, bool, error) } func validHookEventKinds() map[string]string { - runtimeKinds := []runtimeevents.Kind{ - runtimeevents.KindAgentTurnStart, - runtimeevents.KindAgentTurnEnd, - runtimeevents.KindAgentLLMRequest, - runtimeevents.KindAgentLLMDelta, - runtimeevents.KindAgentLLMResponse, - runtimeevents.KindAgentLLMRetry, - runtimeevents.KindAgentContextCompress, - runtimeevents.KindAgentSessionSummarize, - runtimeevents.KindAgentToolExecStart, - runtimeevents.KindAgentToolExecEnd, - runtimeevents.KindAgentToolExecSkipped, - runtimeevents.KindAgentSteeringInjected, - runtimeevents.KindAgentFollowUpQueued, - runtimeevents.KindAgentInterruptReceived, - runtimeevents.KindAgentSubTurnSpawn, - runtimeevents.KindAgentSubTurnEnd, - runtimeevents.KindAgentSubTurnResultDelivered, - runtimeevents.KindAgentSubTurnOrphan, - runtimeevents.KindAgentError, - } + runtimeKinds := runtimeevents.KnownKinds() kinds := make(map[string]string, len(runtimeKinds)*2) for _, kind := range runtimeKinds { kinds[kind.String()] = kind.String() diff --git a/pkg/agent/hook_mount_test.go b/pkg/agent/hook_mount_test.go index bf98e6e03..5cd64af7b 100644 --- a/pkg/agent/hook_mount_test.go +++ b/pkg/agent/hook_mount_test.go @@ -163,6 +163,8 @@ func TestProcessHookObserveKindsFromConfigAcceptsRuntimeNames(t *testing.T) { kinds, enabled, err := processHookObserveKindsFromConfig([]string{ "tool_exec_start", "agent.tool.exec_end", + "gateway.ready", + "mcp.server.failed", }) if err != nil { t.Fatalf("processHookObserveKindsFromConfig failed: %v", err) @@ -171,7 +173,7 @@ func TestProcessHookObserveKindsFromConfigAcceptsRuntimeNames(t *testing.T) { t.Fatal("expected observe to be enabled") } - want := []string{"agent.tool.exec_start", "agent.tool.exec_end"} + want := []string{"agent.tool.exec_start", "agent.tool.exec_end", "gateway.ready", "mcp.server.failed"} if !slices.Equal(kinds, want) { t.Fatalf("observe kinds = %v, want %v", kinds, want) } diff --git a/pkg/agent/runtime_event_logger_test.go b/pkg/agent/runtime_event_logger_test.go index a64529314..1c95b365c 100644 --- a/pkg/agent/runtime_event_logger_test.go +++ b/pkg/agent/runtime_event_logger_test.go @@ -102,6 +102,32 @@ func TestRuntimeEventLogFieldsSummarizeAgentPayload(t *testing.T) { } } +func TestRuntimeEventLogFieldsIncludeSafeAttrs(t *testing.T) { + fields := runtimeEventLogFields(runtimeevents.Event{ + ID: "evt-gateway", + Kind: runtimeevents.KindGatewayReady, + Severity: runtimeevents.SeverityInfo, + Attrs: map[string]any{ + "duration_ms": 42, + "error": "startup failed", + "event_kind": "conflict", + }, + }) + + if fields["duration_ms"] != 42 || fields["error"] != "startup failed" { + t.Fatalf("missing safe attrs: %#v", fields) + } + if fields["event_kind"] != runtimeevents.KindGatewayReady.String() { + t.Fatalf("event_kind overwritten by attrs: %#v", fields) + } + if fields["attr_event_kind"] != "conflict" { + t.Fatalf("conflicting attr not preserved with prefix: %#v", fields) + } + if _, ok := fields["payload"]; ok { + t.Fatalf("raw payload should not be included by runtimeEventLogFields: %#v", fields) + } +} + func runtimeEventLoggerStateForTest( al *AgentLoop, ) (*runtimeEventLogger, runtimeevents.Subscription) { diff --git a/pkg/bus/bus.go b/pkg/bus/bus.go index fe01f31d5..dee67d87c 100644 --- a/pkg/bus/bus.go +++ b/pkg/bus/bus.go @@ -55,6 +55,7 @@ type MessageBus struct { // EventPublisher is the minimal runtime event publisher used by MessageBus. type EventPublisher interface { Publish(ctx context.Context, evt runtimeevents.Event) runtimeevents.PublishResult + PublishNonBlocking(evt runtimeevents.Event) runtimeevents.PublishResult } func NewMessageBus() *MessageBus { diff --git a/pkg/bus/bus_test.go b/pkg/bus/bus_test.go index e3abdc0e6..a0a9e1e14 100644 --- a/pkg/bus/bus_test.go +++ b/pkg/bus/bus_test.go @@ -203,6 +203,9 @@ func TestMessageBusPublishesRuntimeFailureAndCloseEvents(t *testing.T) { failed.Severity != runtimeevents.SeverityError { t.Fatalf("publish failed event = %+v", failed) } + if failed.Attrs["stream"] != "inbound" || failed.Attrs["error"] == "" { + t.Fatalf("publish failed attrs = %#v, want stream and error", failed.Attrs) + } if err := mb.PublishOutbound(context.Background(), OutboundMessage{ Context: NewOutboundContext("telegram", "chat-1", ""), @@ -213,9 +216,13 @@ func TestMessageBusPublishesRuntimeFailureAndCloseEvents(t *testing.T) { mb.Close() seen := map[runtimeevents.Kind]bool{} + var drainedAttrs map[string]any for range 3 { evt := receiveBusRuntimeEvent(t, eventsCh) seen[evt.Kind] = true + if evt.Kind == runtimeevents.KindBusCloseDrained { + drainedAttrs = evt.Attrs + } } for _, kind := range []runtimeevents.Kind{ runtimeevents.KindBusCloseStarted, @@ -226,6 +233,9 @@ func TestMessageBusPublishesRuntimeFailureAndCloseEvents(t *testing.T) { t.Fatalf("missing %s event, seen=%v", kind, seen) } } + if drainedAttrs["drained"] != 1 { + t.Fatalf("bus close drained attrs = %#v, want drained count", drainedAttrs) + } } func receiveBusRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { diff --git a/pkg/bus/events.go b/pkg/bus/events.go index c542892a1..4640ed1fc 100644 --- a/pkg/bus/events.go +++ b/pkg/bus/events.go @@ -1,14 +1,9 @@ package bus import ( - "context" - "time" - runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) -const busEventPublishTimeout = 100 * time.Millisecond - type busPublishFailedPayload struct { Stream string `json:"stream"` Error string `json:"error"` @@ -27,9 +22,7 @@ func (mb *MessageBus) publishFailure(stream string, scope runtimeevents.Scope, e return } - ctx, cancel := context.WithTimeout(context.Background(), busEventPublishTimeout) - defer cancel() - publisher.Publish(ctx, runtimeevents.Event{ + publisher.PublishNonBlocking(runtimeevents.Event{ Kind: runtimeevents.KindBusPublishFailed, Source: runtimeevents.Source{Component: "bus", Name: stream}, Scope: scope, @@ -38,6 +31,10 @@ func (mb *MessageBus) publishFailure(stream string, scope runtimeevents.Scope, e Stream: stream, Error: err.Error(), }, + Attrs: map[string]any{ + "stream": stream, + "error": err.Error(), + }, }) } @@ -50,13 +47,16 @@ func (mb *MessageBus) publishCloseEvent(kind runtimeevents.Kind, drained int) { return } - ctx, cancel := context.WithTimeout(context.Background(), busEventPublishTimeout) - defer cancel() - publisher.Publish(ctx, runtimeevents.Event{ + attrs := map[string]any{} + if drained > 0 { + attrs["drained"] = drained + } + publisher.PublishNonBlocking(runtimeevents.Event{ Kind: kind, Source: runtimeevents.Source{Component: "bus"}, Severity: runtimeevents.SeverityInfo, Payload: busClosePayload{Drained: drained}, + Attrs: attrs, }) } diff --git a/pkg/channels/events.go b/pkg/channels/events.go index f731b84c5..60e5640f0 100644 --- a/pkg/channels/events.go +++ b/pkg/channels/events.go @@ -1,15 +1,10 @@ package channels import ( - "context" - "time" - "github.com/sipeed/picoclaw/pkg/bus" runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) -const channelEventPublishTimeout = 100 * time.Millisecond - func channelTypeForEvent(m *Manager, channelName string) string { if m == nil || m.config == nil { return channelName @@ -33,17 +28,51 @@ func (m *Manager) publishChannelEvent( if scope.Channel == "" { scope.Channel = channelName } - ctx, cancel := context.WithTimeout(context.Background(), channelEventPublishTimeout) - defer cancel() - m.runtimeEvents.Publish(ctx, runtimeevents.Event{ + m.runtimeEvents.PublishNonBlocking(runtimeevents.Event{ Kind: kind, Source: runtimeevents.Source{Component: "channel", Name: channelName}, Scope: scope, Severity: severity, Payload: payload, + Attrs: channelEventAttrs(payload), }) } +func channelEventAttrs(payload any) map[string]any { + switch payload := payload.(type) { + case ChannelLifecyclePayload: + attrs := map[string]any{} + setAttrString(attrs, "type", payload.Type) + setAttrString(attrs, "error", payload.Error) + return attrs + case ChannelOutboundPayload: + attrs := map[string]any{} + if payload.Media { + attrs["media"] = payload.Media + } + if payload.ContentLen > 0 { + attrs["content_len"] = payload.ContentLen + } + if len(payload.MessageIDs) > 0 { + attrs["message_ids_count"] = len(payload.MessageIDs) + } + setAttrString(attrs, "reply_to_message_id", payload.ReplyToMessageID) + setAttrString(attrs, "error", payload.Error) + if payload.Retries > 0 { + attrs["retries"] = payload.Retries + } + return attrs + default: + return nil + } +} + +func setAttrString(attrs map[string]any, key, value string) { + if value != "" { + attrs[key] = value + } +} + func (m *Manager) publishOutboundSent( channelName string, msg bus.OutboundMessage, diff --git a/pkg/channels/manager_test.go b/pkg/channels/manager_test.go index 8680a08a8..5369f7b71 100644 --- a/pkg/channels/manager_test.go +++ b/pkg/channels/manager_test.go @@ -380,6 +380,9 @@ func TestSendWithRetryPublishesOutboundRuntimeEvents(t *testing.T) { if sent.Kind != runtimeevents.KindChannelMessageOutboundSent || sent.Scope.ChatID != "chat-1" { t.Fatalf("sent event = %+v", sent) } + if sent.Attrs["content_len"] != 5 { + t.Fatalf("sent attrs = %#v, want content_len", sent.Attrs) + } failWorker := &channelWorker{ ch: &mockChannel{ @@ -402,6 +405,9 @@ func TestSendWithRetryPublishesOutboundRuntimeEvents(t *testing.T) { if failed.Severity != runtimeevents.SeverityError { t.Fatalf("failed severity = %q", failed.Severity) } + if failed.Attrs["error"] == "" || failed.Attrs["retries"] != maxRetries { + t.Fatalf("failed attrs = %#v, want error and retries", failed.Attrs) + } } func TestSendWithRetry_TemporaryThenSuccess(t *testing.T) { diff --git a/pkg/events/bus.go b/pkg/events/bus.go index 80ed9eb80..f193ccb74 100644 --- a/pkg/events/bus.go +++ b/pkg/events/bus.go @@ -14,6 +14,7 @@ var globalEventSeq atomic.Uint64 // Bus publishes runtime events and creates filtered channels. type Bus interface { Publish(ctx context.Context, evt Event) PublishResult + PublishNonBlocking(evt Event) PublishResult Channel() EventChannel Close() error Stats() Stats @@ -30,9 +31,10 @@ type PublishResult struct { // EventBus is an in-process runtime event broadcaster. type EventBus struct { - mu sync.RWMutex - subs map[uint64]*eventSubscription - closed bool + mu sync.RWMutex + subs map[uint64]*eventSubscription + orderedSubs []*eventSubscription + closed bool nextSubID atomic.Uint64 published atomic.Uint64 @@ -53,6 +55,15 @@ func NewBus() *EventBus { // Publish broadcasts evt to subscriptions whose filters match it. func (b *EventBus) Publish(ctx context.Context, evt Event) PublishResult { + return b.publish(ctx, evt, false) +} + +// PublishNonBlocking broadcasts evt without waiting for subscriber queue capacity. +func (b *EventBus) PublishNonBlocking(evt Event) PublishResult { + return b.publish(context.Background(), evt, true) +} + +func (b *EventBus) publish(ctx context.Context, evt Event, nonBlocking bool) PublishResult { if b == nil { return PublishResult{Closed: true} } @@ -82,7 +93,7 @@ func (b *EventBus) Publish(ctx context.Context, evt Event) PublishResult { result.Matched++ b.matched.Add(1) - delivery := sub.enqueue(ctx, evt) + delivery := sub.enqueue(ctx, evt, nonBlocking) if delivery.closed { continue } @@ -114,11 +125,9 @@ func (b *EventBus) Close() error { return nil } b.closed = true - subs := make([]*eventSubscription, 0, len(b.subs)) - for id, sub := range b.subs { - subs = append(subs, sub) - delete(b.subs, id) - } + subs := b.orderedSubs + b.subs = nil + b.orderedSubs = nil b.mu.Unlock() for _, sub := range subs { @@ -135,14 +144,9 @@ func (b *EventBus) Stats() Stats { b.mu.RLock() closed := b.closed - subs := make([]*eventSubscription, 0, len(b.subs)) - for _, sub := range b.subs { - subs = append(subs, sub) - } + subs := b.orderedSubs b.mu.RUnlock() - sortSubscriptions(subs) - stats := Stats{ Published: b.published.Load(), Matched: b.matched.Load(), @@ -180,6 +184,7 @@ func (b *EventBus) subscribe( return nil, ErrBusClosed } b.subs[id] = sub + b.rebuildOrderedSubscribersLocked() b.mu.Unlock() if handler != nil { @@ -194,6 +199,7 @@ func (b *EventBus) unsubscribe(id uint64) { sub, ok := b.subs[id] if ok { delete(b.subs, id) + b.rebuildOrderedSubscribersLocked() } b.mu.Unlock() @@ -210,12 +216,16 @@ func (b *EventBus) snapshotSubscribers() ([]*eventSubscription, bool) { return nil, true } + return b.orderedSubs, false +} + +func (b *EventBus) rebuildOrderedSubscribersLocked() { subs := make([]*eventSubscription, 0, len(b.subs)) for _, sub := range b.subs { subs = append(subs, sub) } sortSubscriptions(subs) - return subs, false + b.orderedSubs = subs } func sortSubscriptions(subs []*eventSubscription) { diff --git a/pkg/events/events_test.go b/pkg/events/events_test.go index 19b9df96d..6991e8291 100644 --- a/pkg/events/events_test.go +++ b/pkg/events/events_test.go @@ -131,6 +131,105 @@ func TestBlockRespectsContext(t *testing.T) { } } +func TestPublishNonBlockingDropsForFullBlockSubscriber(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + sub, _, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "block", Buffer: 1, Backpressure: Block}, + ) + if err != nil { + t.Fatalf("SubscribeChan failed: %v", err) + } + + first := bus.PublishNonBlocking(Event{Kind: Kind("test.first")}) + if first.Delivered != 1 { + t.Fatalf("first PublishNonBlocking = %+v, want one delivered event", first) + } + + resultCh := make(chan PublishResult, 1) + go func() { + resultCh <- bus.PublishNonBlocking(Event{Kind: Kind("test.second")}) + }() + + select { + case second := <-resultCh: + if second.Matched != 1 || second.Delivered != 0 || second.Dropped != 1 || second.Blocked != 0 { + t.Fatalf("second PublishNonBlocking = %+v, want non-blocking drop", second) + } + case <-time.After(100 * time.Millisecond): + t.Fatal("PublishNonBlocking blocked on full Block subscriber") + } + + if got := sub.Stats().Dropped; got != 1 { + t.Fatalf("subscription dropped = %d, want 1", got) + } +} + +func TestStatsSubscribersKeepPriorityOrder(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + low, _, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "low", Priority: -1}, + ) + if err != nil { + t.Fatalf("SubscribeChan low failed: %v", err) + } + high, _, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "high", Priority: 10}, + ) + if err != nil { + t.Fatalf("SubscribeChan high failed: %v", err) + } + peer, _, err := bus.Channel().SubscribeChan( + context.Background(), + SubscribeOptions{Name: "peer", Priority: 10}, + ) + if err != nil { + t.Fatalf("SubscribeChan peer failed: %v", err) + } + + stats := bus.Stats() + got := []string{ + stats.SubscriberStats[0].Name, + stats.SubscriberStats[1].Name, + stats.SubscriberStats[2].Name, + } + want := []string{"high", "peer", "low"} + if got[0] != want[0] || got[1] != want[1] || got[2] != want[2] { + t.Fatalf("subscriber order = %v, want %v", got, want) + } + + if err := high.Close(); err != nil { + t.Fatalf("Close high failed: %v", err) + } + + stats = bus.Stats() + got = []string{ + stats.SubscriberStats[0].Name, + stats.SubscriberStats[1].Name, + } + want = []string{"peer", "low"} + if got[0] != want[0] || got[1] != want[1] { + t.Fatalf("subscriber order after unsubscribe = %v, want %v", got, want) + } + + if err := peer.Close(); err != nil { + t.Fatalf("Close peer failed: %v", err) + } + if err := low.Close(); err != nil { + t.Fatalf("Close low failed: %v", err) + } +} + func receiveEvent(t *testing.T, ch <-chan Event) Event { t.Helper() diff --git a/pkg/events/kind.go b/pkg/events/kind.go index 85e61f741..b9327e155 100644 --- a/pkg/events/kind.go +++ b/pkg/events/kind.go @@ -101,3 +101,56 @@ const ( // KindMCPToolCallEnd is emitted when an MCP tool call ends. KindMCPToolCallEnd Kind = "mcp.tool.call.end" ) + +var knownKinds = []Kind{ + KindAgentTurnStart, + KindAgentTurnEnd, + KindAgentLLMRequest, + KindAgentLLMDelta, + KindAgentLLMResponse, + KindAgentLLMRetry, + KindAgentContextCompress, + KindAgentSessionSummarize, + KindAgentToolExecStart, + KindAgentToolExecEnd, + KindAgentToolExecSkipped, + KindAgentSteeringInjected, + KindAgentFollowUpQueued, + KindAgentInterruptReceived, + KindAgentSubTurnSpawn, + KindAgentSubTurnEnd, + KindAgentSubTurnResultDelivered, + KindAgentSubTurnOrphan, + KindAgentError, + KindChannelLifecycleStarted, + KindChannelLifecycleInitialized, + KindChannelLifecycleStartFailed, + KindChannelLifecycleStopped, + KindChannelWebhookRegistered, + KindChannelWebhookUnregistered, + KindChannelMessageOutboundQueued, + KindChannelMessageOutboundSent, + KindChannelMessageOutboundFailed, + KindChannelRateLimited, + KindBusPublishFailed, + KindBusCloseStarted, + KindBusCloseCompleted, + KindBusCloseDrained, + KindGatewayStart, + KindGatewayReady, + KindGatewayShutdown, + KindGatewayReloadStarted, + KindGatewayReloadCompleted, + KindGatewayReloadFailed, + KindMCPServerConnected, + KindMCPServerConnecting, + KindMCPServerFailed, + KindMCPToolDiscovered, + KindMCPToolCallStart, + KindMCPToolCallEnd, +} + +// KnownKinds returns the runtime event kinds declared by this package. +func KnownKinds() []Kind { + return append([]Kind(nil), knownKinds...) +} diff --git a/pkg/events/subscription.go b/pkg/events/subscription.go index 1b3977300..6619707a7 100644 --- a/pkg/events/subscription.go +++ b/pkg/events/subscription.go @@ -28,8 +28,11 @@ type SubscribeOptions struct { Priority int Concurrency ConcurrencyKind Backpressure BackpressurePolicy - Timeout time.Duration - PanicPolicy PanicPolicy + // Timeout bounds how long the subscription worker waits for one handler call. + // Handlers should still honor ctx cancellation; timed-out calls keep running + // until their handler returns. + Timeout time.Duration + PanicPolicy PanicPolicy } // ConcurrencyKind controls how handler subscriptions process queued events. @@ -107,6 +110,11 @@ type eventSubscription struct { counters subscriberCounters } +type handlerResult struct { + err error + panicked bool +} + func normalizeSubscribeOptions(opts SubscribeOptions) SubscribeOptions { if opts.Buffer <= 0 { opts.Buffer = defaultSubscriberBuffer @@ -234,26 +242,54 @@ func (s *eventSubscription) handle(ctx context.Context, evt Event) { if ctx == nil { ctx = context.Background() } - if s.opts.Timeout > 0 { - var cancel context.CancelFunc - ctx, cancel = context.WithTimeout(ctx, s.opts.Timeout) - defer cancel() + + if s.opts.Timeout <= 0 { + s.recordHandlerResult(ctx, s.invokeHandler(ctx, evt)) + return } + ctx, cancel := context.WithTimeout(ctx, s.opts.Timeout) + defer cancel() + + done := make(chan handlerResult, 1) + go func() { + done <- s.invokeHandler(ctx, evt) + }() + + select { + case result := <-done: + s.recordHandlerResult(ctx, result) + case <-ctx.Done(): + if errors.Is(ctx.Err(), context.DeadlineExceeded) { + s.counters.timedOut.Add(1) + } + s.counters.failed.Add(1) + } +} + +func (s *eventSubscription) invokeHandler(ctx context.Context, evt Event) (result handlerResult) { if s.opts.PanicPolicy != Crash { defer func() { if recovered := recover(); recovered != nil { s.counters.panicked.Add(1) + result.panicked = true log.Printf("events: subscriber %q recovered panic: %v", s.name, recovered) } }() } - err := s.handler(ctx, evt) + result.err = s.handler(ctx, evt) + return result +} + +func (s *eventSubscription) recordHandlerResult(ctx context.Context, result handlerResult) { + if result.panicked { + return + } if errors.Is(ctx.Err(), context.DeadlineExceeded) { s.counters.timedOut.Add(1) } - if err != nil { + if result.err != nil { s.counters.failed.Add(1) return } @@ -303,11 +339,15 @@ type deliveryResult struct { closed bool } -func (s *eventSubscription) enqueue(ctx context.Context, evt Event) deliveryResult { +func (s *eventSubscription) enqueue(ctx context.Context, evt Event, nonBlocking bool) deliveryResult { if ctx == nil { ctx = context.Background() } + if nonBlocking { + return s.enqueueNonBlocking(evt) + } + if s.opts.Backpressure == Block { return s.enqueueBlocking(ctx, evt) } @@ -343,6 +383,21 @@ func (s *eventSubscription) enqueueBlocking(ctx context.Context, evt Event) deli return s.enqueueBlock(ctx, evt) } +func (s *eventSubscription) enqueueNonBlocking(evt Event) deliveryResult { + s.mu.RLock() + defer s.mu.RUnlock() + + if s.closed { + return deliveryResult{closed: true} + } + + s.counters.received.Add(1) + if s.opts.Backpressure == DropOldest { + return s.enqueueDropOldest(evt) + } + return s.enqueueDropNewest(evt) +} + func (s *eventSubscription) enqueueDropNewest(evt Event) deliveryResult { select { case <-s.closing: diff --git a/pkg/events/subscription_test.go b/pkg/events/subscription_test.go index 44d4be64b..8fde731cc 100644 --- a/pkg/events/subscription_test.go +++ b/pkg/events/subscription_test.go @@ -185,6 +185,45 @@ func TestLockedHandlerProcessesSequentially(t *testing.T) { } } +func TestHandlerTimeoutDoesNotWedgeLockedSubscription(t *testing.T) { + t.Parallel() + + bus := NewBus() + defer closeBus(t, bus) + + releaseFirst := make(chan struct{}) + defer close(releaseFirst) + + var calls atomic.Uint64 + sub, err := bus.Channel().Subscribe( + context.Background(), + SubscribeOptions{Name: "timeout", Buffer: 2, Concurrency: Locked, Timeout: 20 * time.Millisecond}, + func(context.Context, Event) error { + if calls.Add(1) == 1 { + <-releaseFirst + } + return nil + }, + ) + if err != nil { + t.Fatalf("Subscribe failed: %v", err) + } + + bus.Publish(context.Background(), Event{Kind: Kind("test.first")}) + waitForStat(t, func() uint64 { + return sub.Stats().TimedOut + }, 1) + + bus.Publish(context.Background(), Event{Kind: Kind("test.second")}) + waitForStat(t, func() uint64 { + return sub.Stats().Handled + }, 1) + + if got := sub.Stats().Failed; got != 1 { + t.Fatalf("subscription failed = %d, want timeout failure", got) + } +} + func waitForSubscriptionDone(t *testing.T, sub Subscription) { t.Helper() diff --git a/pkg/gateway/events.go b/pkg/gateway/events.go index fd263fba6..0f454ed7d 100644 --- a/pkg/gateway/events.go +++ b/pkg/gateway/events.go @@ -1,15 +1,12 @@ package gateway import ( - "context" "time" "github.com/sipeed/picoclaw/pkg/agent" runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) -const gatewayEventPublishTimeout = 100 * time.Millisecond - type gatewayEventPayload struct { DurationMS int64 `json:"duration_ms,omitempty"` Error string `json:"error,omitempty"` @@ -35,12 +32,22 @@ func publishGatewayEvent( payload.Error = err.Error() } - ctx, cancel := context.WithTimeout(context.Background(), gatewayEventPublishTimeout) - defer cancel() - al.RuntimeEventBus().Publish(ctx, runtimeevents.Event{ + al.RuntimeEventBus().PublishNonBlocking(runtimeevents.Event{ Kind: kind, Source: runtimeevents.Source{Component: "gateway"}, Severity: severity, Payload: payload, + Attrs: gatewayEventAttrs(payload), }) } + +func gatewayEventAttrs(payload gatewayEventPayload) map[string]any { + attrs := map[string]any{} + if payload.DurationMS > 0 { + attrs["duration_ms"] = payload.DurationMS + } + if payload.Error != "" { + attrs["error"] = payload.Error + } + return attrs +} diff --git a/pkg/gateway/gateway.go b/pkg/gateway/gateway.go index dd579ed7e..4fd06d836 100644 --- a/pkg/gateway/gateway.go +++ b/pkg/gateway/gateway.go @@ -267,7 +267,7 @@ func Run(debug bool, homePath, configPath string, allowEmptyStartup bool) (runEr select { case <-sigChan: logger.Info("Shutting down...") - shutdownGateway(runningServices, agentLoop, provider, true) + shutdownGateway(runningServices, agentLoop, provider, msgBus, true) return nil case newCfg := <-configReloadChan: if !runningServices.reloading.CompareAndSwap(false, true) { @@ -510,6 +510,7 @@ func shutdownGateway( runningServices *services, agentLoop *agent.AgentLoop, provider providers.LLMProvider, + msgBus *bus.MessageBus, fullShutdown bool, ) { publishGatewayEvent(agentLoop, runtimeevents.KindGatewayShutdown, time.Time{}, nil) @@ -520,6 +521,10 @@ func shutdownGateway( stopAndCleanupServices(runningServices, gracefulShutdownTimeout, false) + if fullShutdown && msgBus != nil { + msgBus.Close() + } + agentLoop.Stop() agentLoop.Close() diff --git a/pkg/gateway/gateway_test.go b/pkg/gateway/gateway_test.go index 9af833b6b..ab3833ba6 100644 --- a/pkg/gateway/gateway_test.go +++ b/pkg/gateway/gateway_test.go @@ -2,6 +2,7 @@ package gateway import ( "context" + "errors" "fmt" "os" "os/exec" @@ -159,6 +160,42 @@ func TestPublishGatewayEvent(t *testing.T) { if payload.DurationMS <= 0 { t.Fatalf("DurationMS = %d, want positive", payload.DurationMS) } + if evt.Attrs["duration_ms"] == nil { + t.Fatalf("gateway event attrs missing duration_ms: %#v", evt.Attrs) + } +} + +func TestShutdownGatewayClosesMessageBus(t *testing.T) { + msgBus := bus.NewMessageBus() + al := agent.NewAgentLoop( + config.DefaultConfig(), + msgBus, + &startupBlockedProvider{reason: "not used"}, + ) + msgBus.SetEventPublisher(al.RuntimeEventBus()) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + sub, eventsCh, err := al.RuntimeEventBus().Channel().OfKind(runtimeevents.KindBusCloseCompleted).SubscribeChan( + ctx, + runtimeevents.SubscribeOptions{Name: "bus-close-test", Buffer: 4}, + ) + if err != nil { + t.Fatalf("SubscribeChan() error = %v", err) + } + defer func() { + _ = sub.Close() + }() + + shutdownGateway(&services{}, al, &startupBlockedProvider{reason: "not used"}, msgBus, true) + + evt := receiveGatewayRuntimeEvent(t, eventsCh) + if evt.Kind != runtimeevents.KindBusCloseCompleted { + t.Fatalf("shutdown event kind = %q, want %q", evt.Kind, runtimeevents.KindBusCloseCompleted) + } + if err := msgBus.PublishVoiceControl(context.Background(), bus.VoiceControl{}); !errors.Is(err, bus.ErrBusClosed) { + t.Fatalf("PublishVoiceControl after shutdown error = %v, want %v", err, bus.ErrBusClosed) + } } func receiveGatewayRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { diff --git a/pkg/mcp/events.go b/pkg/mcp/events.go index 843fa9088..3b7f53f96 100644 --- a/pkg/mcp/events.go +++ b/pkg/mcp/events.go @@ -1,15 +1,10 @@ package mcp import ( - "context" - "time" - "github.com/sipeed/picoclaw/pkg/config" runtimeevents "github.com/sipeed/picoclaw/pkg/events" ) -const mcpEventPublishTimeout = 100 * time.Millisecond - func (m *Manager) publishServerEvent( kind runtimeevents.Kind, serverName string, @@ -36,13 +31,12 @@ func (m *Manager) publishServerEvent( payload.Error = err.Error() } - ctx, cancel := context.WithTimeout(context.Background(), mcpEventPublishTimeout) - defer cancel() - m.runtimeEvents.Publish(ctx, runtimeevents.Event{ + m.runtimeEvents.PublishNonBlocking(runtimeevents.Event{ Kind: kind, Source: runtimeevents.Source{Component: "mcp", Name: serverName}, Severity: severity, Payload: payload, + Attrs: mcpServerEventAttrs(payload), }) } @@ -57,16 +51,33 @@ func (m *Manager) publishToolDiscovered(serverName string, cfg config.MCPServerC Command: cfg.Command, Tool: toolName, } - ctx, cancel := context.WithTimeout(context.Background(), mcpEventPublishTimeout) - defer cancel() - m.runtimeEvents.Publish(ctx, runtimeevents.Event{ + m.runtimeEvents.PublishNonBlocking(runtimeevents.Event{ Kind: runtimeevents.KindMCPToolDiscovered, Source: runtimeevents.Source{Component: "mcp", Name: serverName}, Severity: runtimeevents.SeverityInfo, Payload: payload, + Attrs: mcpServerEventAttrs(payload), }) } +func mcpServerEventAttrs(payload ServerEventPayload) map[string]any { + attrs := map[string]any{} + setMCPAttrString(attrs, "server", payload.Server) + setMCPAttrString(attrs, "type", payload.Type) + setMCPAttrString(attrs, "tool", payload.Tool) + if payload.ToolCount > 0 { + attrs["tool_count"] = payload.ToolCount + } + setMCPAttrString(attrs, "error", payload.Error) + return attrs +} + +func setMCPAttrString(attrs map[string]any, key, value string) { + if value != "" { + attrs[key] = value + } +} + func mcpTransportType(cfg config.MCPServerConfig) string { if cfg.Type != "" { return cfg.Type diff --git a/pkg/mcp/manager_test.go b/pkg/mcp/manager_test.go index 17b272820..5789a37a9 100644 --- a/pkg/mcp/manager_test.go +++ b/pkg/mcp/manager_test.go @@ -300,6 +300,11 @@ func TestConnectServerPublishesRuntimeEvents(t *testing.T) { connected.Severity != runtimeevents.SeverityInfo { t.Fatalf("connected event = %+v", connected) } + if connected.Attrs["server"] != "good" || + connected.Attrs["type"] != "stdio" || + connected.Attrs["tool_count"] != 1 { + t.Fatalf("connected attrs = %#v", connected.Attrs) + } err = mgr.ConnectServer(context.Background(), "bad", config.MCPServerConfig{ Type: "stdio", @@ -314,6 +319,9 @@ func TestConnectServerPublishesRuntimeEvents(t *testing.T) { failed.Severity != runtimeevents.SeverityError { t.Fatalf("failed event = %+v", failed) } + if failed.Attrs["server"] != "bad" || failed.Attrs["error"] != "connect failed" { + t.Fatalf("failed attrs = %#v", failed.Attrs) + } } func receiveMCPRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { diff --git a/pkg/tools/integration/mcp_tool.go b/pkg/tools/integration/mcp_tool.go index 1ee86a4a9..8cfc1de5e 100644 --- a/pkg/tools/integration/mcp_tool.go +++ b/pkg/tools/integration/mcp_tool.go @@ -310,17 +310,31 @@ func (t *MCPTool) publishRuntimeEvent( severity = runtimeevents.SeverityError } - publishCtx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) - defer cancel() - t.runtimeEvents.Publish(publishCtx, runtimeevents.Event{ + t.runtimeEvents.PublishNonBlocking(runtimeevents.Event{ Kind: kind, Source: runtimeevents.Source{Component: "mcp", Name: t.serverName}, Scope: scope, Severity: severity, Payload: payload, + Attrs: mcpToolCallEventAttrs(payload), }) } +func mcpToolCallEventAttrs(payload MCPToolCallPayload) map[string]any { + attrs := map[string]any{ + "server": payload.Server, + "tool": payload.Tool, + "duration_ms": payload.DurationMS, + } + if payload.IsError { + attrs["is_error"] = payload.IsError + } + if payload.Error != "" { + attrs["error"] = payload.Error + } + return attrs +} + // extractContentText extracts text from MCP content array func extractContentText(content []mcp.Content) string { var parts []string diff --git a/pkg/tools/integration/mcp_tool_test.go b/pkg/tools/integration/mcp_tool_test.go index f346e5329..7c961e1e1 100644 --- a/pkg/tools/integration/mcp_tool_test.go +++ b/pkg/tools/integration/mcp_tool_test.go @@ -350,6 +350,11 @@ func TestMCPTool_Execute_PublishesRuntimeEvents(t *testing.T) { if payload.Server != "github" || payload.Tool != "search_repos" || payload.IsError { t.Fatalf("ended payload = %+v", payload) } + if ended.Attrs["server"] != "github" || + ended.Attrs["tool"] != "search_repos" || + ended.Attrs["duration_ms"] == nil { + t.Fatalf("ended attrs = %#v", ended.Attrs) + } } func receiveMCPToolRuntimeEvent(t *testing.T, ch <-chan runtimeevents.Event) runtimeevents.Event { From 97b1c3efecc2d5f9050566f4e15596263a743ff7 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Mon, 27 Apr 2026 15:42:18 +0600 Subject: [PATCH 30/53] fix duplicate toolFeedbackArgsPreview function declaration --- config/config.example.json | 4 +- pkg/agent/agent_test.go | 3 +- pkg/agent/agent_utils.go | 15 +---- pkg/agent/pipeline_execute.go | 4 +- pkg/config/config.go | 8 +-- pkg/config/defaults.go | 8 +-- tool_feedback.go | 86 ----------------------------- tool_feedback_test.go | 101 ---------------------------------- 8 files changed, 11 insertions(+), 218 deletions(-) delete mode 100644 tool_feedback.go delete mode 100644 tool_feedback_test.go diff --git a/config/config.example.json b/config/config.example.json index 665a6fd11..30460c231 100644 --- a/config/config.example.json +++ b/config/config.example.json @@ -14,9 +14,7 @@ "tool_feedback": { "enabled": false, "max_args_length": 300, - "separate_messages": false, - "pretty_print": true, - "disable_escape_html": true + "separate_messages": false } } }, diff --git a/pkg/agent/agent_test.go b/pkg/agent/agent_test.go index 6e5bc8191..01657d43a 100644 --- a/pkg/agent/agent_test.go +++ b/pkg/agent/agent_test.go @@ -4519,8 +4519,7 @@ func TestRun_PicoToolFeedbackSuppressesDuplicateInterimAssistantContent(t *testi MaxTokens: 4096, MaxToolIterations: 10, ToolFeedback: config.ToolFeedbackConfig{ - Enabled: true, - PrettyPrint: true, + Enabled: true, }, }, }, diff --git a/pkg/agent/agent_utils.go b/pkg/agent/agent_utils.go index 90d9f43b9..8e42c1493 100644 --- a/pkg/agent/agent_utils.go +++ b/pkg/agent/agent_utils.go @@ -4,7 +4,6 @@ package agent import ( "context" - "encoding/json" "fmt" "maps" "path/filepath" @@ -177,19 +176,7 @@ func toolFeedbackArgsPreview(args map[string]any, maxLen int) string { args = map[string]any{} } - argsJSON, err := json.MarshalIndent(args, "", " ") - if err != nil { - return utils.Truncate(fmt.Sprintf("%v", args), maxLen) - } - return utils.Truncate(string(argsJSON), maxLen) -} - -func toolFeedbackArgsPreviewWithOptions(args map[string]any, maxLen int, prettyPrint, disableEscapeHTML bool) string { - if args == nil { - args = map[string]any{} - } - - argsJSON := utils.FormatArgsJSON(args, prettyPrint, disableEscapeHTML) + argsJSON := utils.FormatArgsJSON(args, true, false) return utils.Truncate(argsJSON, maxLen) } diff --git a/pkg/agent/pipeline_execute.go b/pkg/agent/pipeline_execute.go index ec3514f10..e1be2a74b 100644 --- a/pkg/agent/pipeline_execute.go +++ b/pkg/agent/pipeline_execute.go @@ -91,7 +91,7 @@ toolLoop: feedbackMsg := utils.FormatToolFeedbackMessage( toolName, toolFeedbackExplanation, - toolFeedbackArgsPreviewWithOptions(toolArgs, toolFeedbackMaxLen, al.cfg.Agents.Defaults.ToolFeedback.PrettyPrint, al.cfg.Agents.Defaults.ToolFeedback.DisableEscapeHTML), +toolFeedbackArgsPreview(toolArgs, toolFeedbackMaxLen), ) fbCtx, fbCancel := context.WithTimeout(turnCtx, 3*time.Second) _ = al.bus.PublishOutbound(fbCtx, outboundMessageForTurnWithKind(ts, feedbackMsg, messageKindToolFeedback)) @@ -373,7 +373,7 @@ toolLoop: feedbackMsg := utils.FormatToolFeedbackMessage( toolName, toolFeedbackExplanation, - toolFeedbackArgsPreviewWithOptions(toolArgs, toolFeedbackMaxLen, al.cfg.Agents.Defaults.ToolFeedback.PrettyPrint, al.cfg.Agents.Defaults.ToolFeedback.DisableEscapeHTML), + toolFeedbackArgsPreview(toolArgs, toolFeedbackMaxLen), ) fbCtx, fbCancel := context.WithTimeout(turnCtx, 3*time.Second) _ = al.bus.PublishOutbound(fbCtx, outboundMessageForTurnWithKind(ts, feedbackMsg, messageKindToolFeedback)) diff --git a/pkg/config/config.go b/pkg/config/config.go index b31c2b63d..48a1cccde 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -247,11 +247,9 @@ type SubTurnConfig struct { } type ToolFeedbackConfig struct { - Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` - MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` - SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` - PrettyPrint bool `json:"pretty_print" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_PRETTY_PRINT"` - DisableEscapeHTML bool `json:"disable_escape_html" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_DISABLE_ESCAPE_HTML"` + Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` + MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` + SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` } type AgentDefaults struct { diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index 32e3cbbe1..f3aaca7ab 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -35,11 +35,9 @@ func DefaultConfig() *Config { SummarizeTokenPercent: 75, SteeringMode: "one-at-a-time", ToolFeedback: ToolFeedbackConfig{ - Enabled: false, - MaxArgsLength: 300, - SeparateMessages: false, - PrettyPrint: true, - DisableEscapeHTML: true, + Enabled: false, + MaxArgsLength: 300, + SeparateMessages: false, }, SplitOnMarker: false, }, diff --git a/tool_feedback.go b/tool_feedback.go deleted file mode 100644 index b8cf3c384..000000000 --- a/tool_feedback.go +++ /dev/null @@ -1,86 +0,0 @@ -package utils - -import ( - "bytes" - "encoding/json" - "fmt" - "strings" -) - -const ToolFeedbackContinuationHint = "Continuing the current task." - -func FormatArgsJSON(args map[string]any, prettyPrint, disableEscapeHTML bool) string { - var buf bytes.Buffer - enc := json.NewEncoder(&buf) - if prettyPrint { - enc.SetIndent("", " ") - } - if disableEscapeHTML { - enc.SetEscapeHTML(false) - } - if err := enc.Encode(args); err != nil { - return "{}" - } - return strings.TrimSpace(buf.String()) -} - -func FormatToolFeedbackMessage(toolName, explanation, argsPreview string) string { - toolName = strings.TrimSpace(toolName) - explanation = strings.TrimSpace(explanation) - argsPreview = strings.TrimSpace(argsPreview) - - bodyLines := make([]string, 0, 2) - if explanation != "" { - bodyLines = append(bodyLines, explanation) - } - if argsPreview != "" { - bodyLines = append(bodyLines, "```json\n"+argsPreview+"\n```") - } - body := strings.Join(bodyLines, "\n") - - if toolName == "" { - return body - } - if body == "" { - return fmt.Sprintf("\U0001f527 `%s`", toolName) - } - - return fmt.Sprintf("\U0001f527 `%s`\n%s", toolName, body) -} - -func FitToolFeedbackMessage(content string, maxLen int) string { - content = strings.TrimSpace(content) - if content == "" || maxLen <= 0 { - return "" - } - if len([]rune(content)) <= maxLen { - return content - } - - firstLine, rest, hasRest := strings.Cut(content, "\n") - firstLine = strings.TrimSpace(firstLine) - rest = strings.TrimSpace(rest) - - if !hasRest || rest == "" { - return Truncate(firstLine, maxLen) - } - - if len([]rune(firstLine)) >= maxLen { - return Truncate(firstLine, maxLen) - } - - remaining := maxLen - len([]rune(firstLine)) - 1 - if remaining <= 0 { - return Truncate(firstLine, maxLen) - } - - return firstLine + "\n" + Truncate(rest, remaining) -} - -func Truncate(s string, maxLen int) string { - runes := []rune(s) - if len(runes) <= maxLen { - return s - } - return string(runes[:maxLen]) -} diff --git a/tool_feedback_test.go b/tool_feedback_test.go deleted file mode 100644 index ef76c1506..000000000 --- a/tool_feedback_test.go +++ /dev/null @@ -1,101 +0,0 @@ -package utils - -import ( - "encoding/json" - "testing" -) - -func TestFormatArgsJSON_Defaults(t *testing.T) { - args := map[string]any{"path": "README.md", "line": 42} - got := FormatArgsJSON(args, false, false) - var gotVal, wantVal any - if err := json.Unmarshal([]byte(got), &gotVal); err != nil { - t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) - } - want := `{"path":"README.md","line":42}` - if err := json.Unmarshal([]byte(want), &wantVal); err != nil { - t.Fatalf("invalid test want JSON: %v", err) - } - if !jsonValEq(gotVal, wantVal) { - t.Fatalf("FormatArgsJSON() = %q, want %q", got, want) - } -} - -func TestFormatArgsJSON_PrettyPrint(t *testing.T) { - args := map[string]any{"path": "README.md", "line": 42} - got := FormatArgsJSON(args, true, false) - var gotVal any - if err := json.Unmarshal([]byte(got), &gotVal); err != nil { - t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) - } - want := `{"path":"README.md","line":42}` - var wantVal any - if err := json.Unmarshal([]byte(want), &wantVal); err != nil { - t.Fatalf("invalid test want JSON: %v", err) - } - if !jsonValEq(gotVal, wantVal) { - t.Fatalf("FormatArgsJSON() prettyPrint = %q, want structure %q", got, want) - } -} - -func TestFormatArgsJSON_DisableEscapeHTML(t *testing.T) { - args := map[string]any{"msg": "a < b && c > d"} - got := FormatArgsJSON(args, false, true) - var gotVal, wantVal any - want := `{"msg":"a < b && c > d"}` - if err := json.Unmarshal([]byte(got), &gotVal); err != nil { - t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) - } - if err := json.Unmarshal([]byte(want), &wantVal); err != nil { - t.Fatalf("invalid test want JSON: %v", err) - } - if !jsonValEq(gotVal, wantVal) { - t.Fatalf("FormatArgsJSON() disableEscapeHTML = %q, want %q", got, want) - } -} - -func TestFormatArgsJSON_PrettyPrintAndDisableEscapeHTML(t *testing.T) { - args := map[string]any{"msg": "a < b && c > d"} - got := FormatArgsJSON(args, true, true) - var gotVal, wantVal any - want := `{"msg":"a < b && c > d"}` - if err := json.Unmarshal([]byte(got), &gotVal); err != nil { - t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) - } - if err := json.Unmarshal([]byte(want), &wantVal); err != nil { - t.Fatalf("invalid test want JSON: %v", err) - } - if !jsonValEq(gotVal, wantVal) { - t.Fatalf("FormatArgsJSON() combined = %q, want %q", got, want) - } -} - -func TestFormatArgsJSON_EscapeHTMLByDefault(t *testing.T) { - args := map[string]any{"msg": "a < b && c > d"} - got := FormatArgsJSON(args, false, false) - var gotVal, wantVal any - want := `{"msg":"a \u003c b \u0026\u0026 c \u003e d"}` - if err := json.Unmarshal([]byte(got), &gotVal); err != nil { - t.Fatalf("FormatArgsJSON() returned invalid JSON: %v", err) - } - if err := json.Unmarshal([]byte(want), &wantVal); err != nil { - t.Fatalf("invalid test want JSON: %v", err) - } - if !jsonValEq(gotVal, wantVal) { - t.Fatalf("FormatArgsJSON() default escape = %q, want %q", got, want) - } -} - -func TestFormatArgsJSON_NilArgs(t *testing.T) { - got := FormatArgsJSON(nil, false, false) - want := `null` - if got != want { - t.Fatalf("FormatArgsJSON() nil = %q, want %q", got, want) - } -} - -func jsonValEq(a, b any) bool { - aJSON, _ := json.Marshal(a) - bJSON, _ := json.Marshal(b) - return string(aJSON) == string(bJSON) -} From 8dca2a13195fc5fc6bb3546914e12061dada4cd0 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Mon, 27 Apr 2026 16:05:10 +0600 Subject: [PATCH 31/53] fix: improve error handling and nil consistency in FormatArgsJSON - Use fmt.Sprintf fallback instead of {} on encoding errors - Normalize nil args to {} in FormatArgsJSON for consistent output - Update tests to expect {} instead of null for nil args Based on PR #2670 review feedback from afjcjsbx --- pkg/agent/agent_utils.go | 4 ---- pkg/agent/pipeline_execute.go | 2 +- pkg/utils/tool_feedback.go | 8 +++++++- pkg/utils/tool_feedback_test.go | 2 +- 4 files changed, 9 insertions(+), 7 deletions(-) diff --git a/pkg/agent/agent_utils.go b/pkg/agent/agent_utils.go index 8e42c1493..67524b79c 100644 --- a/pkg/agent/agent_utils.go +++ b/pkg/agent/agent_utils.go @@ -172,10 +172,6 @@ func toolFeedbackExplanationFromMessages(messages []providers.Message) string { } func toolFeedbackArgsPreview(args map[string]any, maxLen int) string { - if args == nil { - args = map[string]any{} - } - argsJSON := utils.FormatArgsJSON(args, true, false) return utils.Truncate(argsJSON, maxLen) } diff --git a/pkg/agent/pipeline_execute.go b/pkg/agent/pipeline_execute.go index e1be2a74b..0cf3eaa9a 100644 --- a/pkg/agent/pipeline_execute.go +++ b/pkg/agent/pipeline_execute.go @@ -91,7 +91,7 @@ toolLoop: feedbackMsg := utils.FormatToolFeedbackMessage( toolName, toolFeedbackExplanation, -toolFeedbackArgsPreview(toolArgs, toolFeedbackMaxLen), + toolFeedbackArgsPreview(toolArgs, toolFeedbackMaxLen), ) fbCtx, fbCancel := context.WithTimeout(turnCtx, 3*time.Second) _ = al.bus.PublishOutbound(fbCtx, outboundMessageForTurnWithKind(ts, feedbackMsg, messageKindToolFeedback)) diff --git a/pkg/utils/tool_feedback.go b/pkg/utils/tool_feedback.go index 4e80e57f3..1834d7f78 100644 --- a/pkg/utils/tool_feedback.go +++ b/pkg/utils/tool_feedback.go @@ -10,6 +10,11 @@ import ( const ToolFeedbackContinuationHint = "Continuing the current task." func FormatArgsJSON(args map[string]any, prettyPrint, disableEscapeHTML bool) string { + // Normalize nil to empty map for consistent output + if args == nil { + args = map[string]any{} + } + var buf bytes.Buffer enc := json.NewEncoder(&buf) if prettyPrint { @@ -19,7 +24,8 @@ func FormatArgsJSON(args map[string]any, prettyPrint, disableEscapeHTML bool) st enc.SetEscapeHTML(false) } if err := enc.Encode(args); err != nil { - return "{}" + // Fallback to fmt.Sprintf to preserve visibility of problematic args + return fmt.Sprintf("%v", args) } return strings.TrimSpace(buf.String()) } diff --git a/pkg/utils/tool_feedback_test.go b/pkg/utils/tool_feedback_test.go index 5fabd3d83..da4accce4 100644 --- a/pkg/utils/tool_feedback_test.go +++ b/pkg/utils/tool_feedback_test.go @@ -143,7 +143,7 @@ func TestFormatArgsJSON_EscapeHTMLByDefault(t *testing.T) { func TestFormatArgsJSON_NilArgs(t *testing.T) { got := FormatArgsJSON(nil, false, false) - want := `null` + want := `{}` if got != want { t.Fatalf("FormatArgsJSON() nil = %q, want %q", got, want) } From 38baf1ccd0ef0f357653747d27519476ff18e26b Mon Sep 17 00:00:00 2001 From: David Siewert Date: Mon, 27 Apr 2026 16:30:51 +0600 Subject: [PATCH 32/53] fix(agent): normalize nil args and improve error handling in FormatArgsJSON - Return fmt.Sprintf fallback instead of {} on encoding errors to preserve visibility - Normalize nil to empty map in FormatArgsJSON for consistent output - Remove redundant nil check in toolFeedbackArgsPreview wrapper - Update test expectation: nil args now return {} not null --- pkg/config/config.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index 48a1cccde..6bb8d3ce6 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -247,8 +247,8 @@ type SubTurnConfig struct { } type ToolFeedbackConfig struct { - Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` - MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` + Enabled bool `json:"enabled" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"` + MaxArgsLength int `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"` SeparateMessages bool `json:"separate_messages" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_SEPARATE_MESSAGES"` } From e656ddf5bbe8fa197c31ec310c019f14932585cb Mon Sep 17 00:00:00 2001 From: David Siewert Date: Mon, 27 Apr 2026 16:47:28 +0600 Subject: [PATCH 33/53] fix: align struct tag spacing in AgentDefaults config --- pkg/config/config.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index 80a7a79a7..c488dff40 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -275,7 +275,7 @@ type AgentDefaults struct { SplitOnMarker bool `json:"split_on_marker" env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker ContextManager string `json:"context_manager,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"` ContextManagerConfig json.RawMessage `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"` - MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` + MaxLLMRetries int `json:"max_llm_retries,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_MAX_LLM_RETRIES"` LLMRetryBackoffSecs int `json:"llm_retry_backoff_secs,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_LLM_RETRY_BACKOFF_SECS"` } From cd7717bc155a440c06d42dad4c1b9c4aaed1d83b Mon Sep 17 00:00:00 2001 From: afjcjsbx Date: Mon, 27 Apr 2026 21:10:30 +0200 Subject: [PATCH 34/53] feat(tool): tool schema semplification --- config/config.example.json | 1 + docs/guides/providers.md | 56 +++++++--- pkg/config/config.go | 85 +++++++------- pkg/config/config_test.go | 30 +++++ pkg/config/model_config_test.go | 18 +++ pkg/config/multikey_test.go | 25 +++-- pkg/providers/common/google_schema.go | 16 ++- pkg/providers/common/tool_schema_transform.go | 59 ++++++++++ pkg/providers/factory_provider.go | 50 +++++---- pkg/providers/factory_provider_test.go | 39 +++++++ pkg/providers/httpapi/gemini_provider.go | 2 +- pkg/providers/httpapi/gemini_provider_test.go | 10 +- pkg/providers/oauth/antigravity_provider.go | 5 +- .../oauth/antigravity_provider_test.go | 15 ++- pkg/providers/tool_schema_transform.go | 84 ++++++++++++++ pkg/providers/tool_schema_transform_test.go | 104 ++++++++++++++++++ web/backend/api/models.go | 63 ++++++----- web/backend/api/models_test.go | 94 ++++++++++++++++ web/frontend/src/api/models.ts | 1 + .../src/components/models/add-model-sheet.tsx | 14 +++ .../components/models/edit-model-sheet.tsx | 15 +++ web/frontend/src/i18n/locales/en.json | 2 + web/frontend/src/i18n/locales/zh.json | 2 + 23 files changed, 654 insertions(+), 136 deletions(-) create mode 100644 pkg/providers/common/tool_schema_transform.go create mode 100644 pkg/providers/tool_schema_transform.go create mode 100644 pkg/providers/tool_schema_transform_test.go diff --git a/config/config.example.json b/config/config.example.json index 30460c231..33eed63d1 100644 --- a/config/config.example.json +++ b/config/config.example.json @@ -41,6 +41,7 @@ }, { "model_name": "gemini", + "_comment": "Optional: set \"tool_schema_transform\": \"simple\" for providers that reject complex tool JSON Schema.", "model": "antigravity/gemini-2.0-flash", "auth_method": "oauth" }, diff --git a/docs/guides/providers.md b/docs/guides/providers.md index d99d8c016..62bbbbe56 100644 --- a/docs/guides/providers.md +++ b/docs/guides/providers.md @@ -116,23 +116,47 @@ This design also enables **multi-agent support** with flexible provider selectio #### `model_list` Entry Fields -| Field | Type | Required | Description | -|-------|------|----------|-------------| -| `model_name` | string | Yes | Unique name used to reference this model in agent config | -| `provider` | string | No | Preferred provider identifier. When present, PicoClaw sends `model` unchanged to that provider | -| `model` | string | Yes | Native model ID when `provider` is set. If `provider` is omitted, the legacy `provider/model` form is still supported | -| `api_keys` | string[] | Yes* | API key(s) for authentication. Multiple keys enable per-request rotation. Not required for local providers (Ollama, LM Studio, VLLM) | -| `api_base` | string | No | Override the default API endpoint URL | -| `proxy` | string | No | HTTP proxy URL for this model entry | -| `user_agent` | string | No | Custom `User-Agent` header sent with API requests (supported by OpenAI-compatible, Gemini, Anthropic, and Azure providers) | -| `request_timeout` | int | No | Request timeout in seconds (default varies by provider) | -| `max_tokens_field` | string | No | Override the max tokens field name in request body (e.g., `max_completion_tokens` for o1 models) | -| `thinking_level` | string | No | Extended thinking level: `off`, `low`, `medium`, `high`, `xhigh`, or `adaptive` | -| `extra_body` | object | No | Additional fields to inject into every request body | +| Field | Type | Required | Description | +|-------|------|----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `model_name` | string | Yes | Unique name used to reference this model in agent config | +| `provider` | string | No | Preferred provider identifier. When present, PicoClaw sends `model` unchanged to that provider | +| `model` | string | Yes | Native model ID when `provider` is set. If `provider` is omitted, the legacy `provider/model` form is still supported | +| `api_keys` | string[] | Yes* | API key(s) for authentication. Multiple keys enable per-request rotation. Not required for local providers (Ollama, LM Studio, VLLM) | +| `api_base` | string | No | Override the default API endpoint URL | +| `proxy` | string | No | HTTP proxy URL for this model entry | +| `user_agent` | string | No | Custom `User-Agent` header sent with API requests (supported by OpenAI-compatible, Gemini, Anthropic, and Azure providers) | +| `request_timeout` | int | No | Request timeout in seconds (default varies by provider) | +| `max_tokens_field` | string | No | Override the max tokens field name in request body (e.g., `max_completion_tokens` for o1 models) | +| `thinking_level` | string | No | Extended thinking level: `off`, `low`, `medium`, `high`, `xhigh`, or `adaptive` | +| `tool_schema_transform` | string | No | Optional compatibility transform for tool parameter schemas. Default: disabled. Supported values: `simple`. | +| `extra_body` | object | No | Additional fields to inject into every request body | | `custom_headers` | object | No | Additional HTTP headers to inject into every request (e.g., `{"X-Source":"coding-plan"}`). If a key matches a built-in header, the custom value overrides the built-in one (e.g., `Authorization`, `User-Agent`, `Content-Type`, `Accept`). | -| `rpm` | int | No | Per-minute request rate limit | -| `fallbacks` | string[] | No | Fallback model names for automatic failover | -| `enabled` | bool | No | Whether this model entry is active (default: `true`) | +| `rpm` | int | No | Per-minute request rate limit | +| `fallbacks` | string[] | No | Fallback model names for automatic failover | +| `enabled` | bool | No | Whether this model entry is active (default: `true`) | + +#### Tool Schema Compatibility + +By default, PicoClaw now forwards tool JSON Schemas unchanged. + +Some providers reject advanced JSON Schema features such as `$ref`, `$defs`, `anyOf`, `oneOf`, `allOf`, `pattern`, or numeric/string constraints inside tool declarations. For those models, you can opt into a compatibility transform per model entry with `tool_schema_transform`. + +Use `simple` when the upstream provider expects the conservative style function schema subset: + +```json +{ + "model_name": "gemini-2.5-flash-safe-tools", + "provider": "gemini", + "model": "gemini-2.5-flash", + "api_keys": ["your-gemini-key"], + "tool_schema_transform": "simple" +} +``` + +Notes: + +- Default behavior is disabled. If you omit `tool_schema_transform`, PicoClaw sends the original tool schema. +- The setting is per model entry, so you can enable it only for the providers that need it. #### Provider / Model Resolution diff --git a/pkg/config/config.go b/pkg/config/config.go index 305c3a5c0..d109f1361 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -17,6 +17,7 @@ import ( "github.com/sipeed/picoclaw/pkg" "github.com/sipeed/picoclaw/pkg/fileutil" "github.com/sipeed/picoclaw/pkg/logger" + providercommon "github.com/sipeed/picoclaw/pkg/providers/common" ) // rrCounter is a global counter for round-robin load balancing across models. @@ -553,12 +554,13 @@ type ModelConfig struct { Workspace string `json:"workspace,omitempty"` // Workspace path for CLI-based providers // Optional optimizations - RPM int `json:"rpm,omitempty"` // Requests per minute limit - MaxTokensField string `json:"max_tokens_field,omitempty"` // Field name for max tokens (e.g., "max_completion_tokens") - RequestTimeout int `json:"request_timeout,omitempty"` - ThinkingLevel string `json:"thinking_level,omitempty"` // Extended thinking: off|low|medium|high|xhigh|adaptive - ExtraBody map[string]any `json:"extra_body,omitempty"` // Additional fields to inject into request body - CustomHeaders map[string]string `json:"custom_headers,omitempty"` // Additional headers to inject into every HTTP request + RPM int `json:"rpm,omitempty"` // Requests per minute limit + MaxTokensField string `json:"max_tokens_field,omitempty"` // Field name for max tokens (e.g., "max_completion_tokens") + RequestTimeout int `json:"request_timeout,omitempty"` + ThinkingLevel string `json:"thinking_level,omitempty"` // Extended thinking: off|low|medium|high|xhigh|adaptive + ToolSchemaTransform string `json:"tool_schema_transform,omitempty"` // Optional tool schema compatibility transform (e.g. "simple") + ExtraBody map[string]any `json:"extra_body,omitempty"` // Additional fields to inject into request body + CustomHeaders map[string]string `json:"custom_headers,omitempty"` // Additional headers to inject into every HTTP request APIKeys SecureStrings `json:"api_keys,omitzero" yaml:"api_keys,omitempty"` // API authentication keys (multiple keys for failover) @@ -595,6 +597,9 @@ func (c *ModelConfig) Validate() error { if c.Model == "" { return fmt.Errorf("model is required") } + if _, err := providercommon.NormalizeToolSchemaTransform(c.ToolSchemaTransform); err != nil { + return err + } return nil } @@ -1419,23 +1424,24 @@ func expandMultiKeyModels(models []*ModelConfig) []*ModelConfig { // Create a copy for the additional key additionalEntry := &ModelConfig{ - ModelName: expandedName, - Provider: m.Provider, - Model: m.Model, - APIBase: m.APIBase, - APIKeys: SimpleSecureStrings(keys[i]), - Proxy: m.Proxy, - AuthMethod: m.AuthMethod, - ConnectMode: m.ConnectMode, - Workspace: m.Workspace, - RPM: m.RPM, - MaxTokensField: m.MaxTokensField, - RequestTimeout: m.RequestTimeout, - ThinkingLevel: m.ThinkingLevel, - ExtraBody: m.ExtraBody, - CustomHeaders: m.CustomHeaders, - UserAgent: m.UserAgent, - isVirtual: true, + ModelName: expandedName, + Provider: m.Provider, + Model: m.Model, + APIBase: m.APIBase, + APIKeys: SimpleSecureStrings(keys[i]), + Proxy: m.Proxy, + AuthMethod: m.AuthMethod, + ConnectMode: m.ConnectMode, + Workspace: m.Workspace, + RPM: m.RPM, + MaxTokensField: m.MaxTokensField, + RequestTimeout: m.RequestTimeout, + ThinkingLevel: m.ThinkingLevel, + ToolSchemaTransform: m.ToolSchemaTransform, + ExtraBody: m.ExtraBody, + CustomHeaders: m.CustomHeaders, + UserAgent: m.UserAgent, + isVirtual: true, } expanded = append(expanded, additionalEntry) fallbackNames = append(fallbackNames, expandedName) @@ -1443,22 +1449,23 @@ func expandMultiKeyModels(models []*ModelConfig) []*ModelConfig { // Create the primary entry with first key and fallbacks primaryEntry := &ModelConfig{ - ModelName: originalName, - Provider: m.Provider, - Model: m.Model, - APIBase: m.APIBase, - Proxy: m.Proxy, - AuthMethod: m.AuthMethod, - ConnectMode: m.ConnectMode, - Workspace: m.Workspace, - RPM: m.RPM, - MaxTokensField: m.MaxTokensField, - RequestTimeout: m.RequestTimeout, - ThinkingLevel: m.ThinkingLevel, - ExtraBody: m.ExtraBody, - CustomHeaders: m.CustomHeaders, - UserAgent: m.UserAgent, - APIKeys: SimpleSecureStrings(keys[0]), + ModelName: originalName, + Provider: m.Provider, + Model: m.Model, + APIBase: m.APIBase, + Proxy: m.Proxy, + AuthMethod: m.AuthMethod, + ConnectMode: m.ConnectMode, + Workspace: m.Workspace, + RPM: m.RPM, + MaxTokensField: m.MaxTokensField, + RequestTimeout: m.RequestTimeout, + ThinkingLevel: m.ThinkingLevel, + ToolSchemaTransform: m.ToolSchemaTransform, + ExtraBody: m.ExtraBody, + CustomHeaders: m.CustomHeaders, + UserAgent: m.UserAgent, + APIKeys: SimpleSecureStrings(keys[0]), } // Prepend new fallbacks to existing ones diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go index 2be1bcc67..a8f32d47d 100644 --- a/pkg/config/config_test.go +++ b/pkg/config/config_test.go @@ -1945,6 +1945,36 @@ func TestModelConfig_CustomHeadersRoundTrip(t *testing.T) { } } +func TestModelConfig_ToolSchemaTransformRoundTrip(t *testing.T) { + dir := t.TempDir() + cfgPath := filepath.Join(dir, "config.json") + + cfg := &Config{ + Version: CurrentVersion, + ModelList: []*ModelConfig{ + { + ModelName: "test-model", + Model: "openai/test", + APIKeys: SimpleSecureStrings("sk-test"), + ToolSchemaTransform: "simple", + }, + }, + } + + if err := SaveConfig(cfgPath, cfg); err != nil { + t.Fatalf("SaveConfig error: %v", err) + } + + loaded, err := LoadConfig(cfgPath) + if err != nil { + t.Fatalf("LoadConfig error: %v", err) + } + + if got := loaded.ModelList[0].ToolSchemaTransform; got != "simple" { + t.Fatalf("ToolSchemaTransform = %q, want %q", got, "simple") + } +} + func TestDefaultConfig_MinimaxExtraBody(t *testing.T) { cfg := DefaultConfig() diff --git a/pkg/config/model_config_test.go b/pkg/config/model_config_test.go index 8fd501155..d22eb290f 100644 --- a/pkg/config/model_config_test.go +++ b/pkg/config/model_config_test.go @@ -158,6 +158,15 @@ func TestModelConfig_Validate(t *testing.T) { }, wantErr: false, }, + { + name: "valid tool schema transform", + config: ModelConfig{ + ModelName: "test", + Model: "openai/gpt-4o", + ToolSchemaTransform: "simple", + }, + wantErr: false, + }, { name: "missing model_name", config: ModelConfig{ @@ -177,6 +186,15 @@ func TestModelConfig_Validate(t *testing.T) { config: ModelConfig{}, wantErr: true, }, + { + name: "invalid tool schema transform", + config: ModelConfig{ + ModelName: "test", + Model: "openai/gpt-4o", + ToolSchemaTransform: "invalid", + }, + wantErr: true, + }, } for _, tt := range tests { diff --git a/pkg/config/multikey_test.go b/pkg/config/multikey_test.go index cb55db938..073cb7826 100644 --- a/pkg/config/multikey_test.go +++ b/pkg/config/multikey_test.go @@ -187,15 +187,16 @@ func TestExpandMultiKeyModels_Deduplication(t *testing.T) { func TestExpandMultiKeyModels_PreservesOtherFields(t *testing.T) { modelCfg := &ModelConfig{ - ModelName: "gpt-4", - Provider: "openrouter", - Model: "openai/gpt-4o", - APIBase: "https://api.example.com", - Proxy: "http://proxy:8080", - RPM: 60, - MaxTokensField: "max_completion_tokens", - RequestTimeout: 30, - ThinkingLevel: "high", + ModelName: "gpt-4", + Provider: "openrouter", + Model: "openai/gpt-4o", + APIBase: "https://api.example.com", + Proxy: "http://proxy:8080", + RPM: 60, + MaxTokensField: "max_completion_tokens", + RequestTimeout: 30, + ThinkingLevel: "high", + ToolSchemaTransform: "simple", } modelCfg.APIKeys = SimpleSecureStrings("key0", "key1") // Use internal field for multi-key testing models := []*ModelConfig{modelCfg} @@ -225,6 +226,9 @@ func TestExpandMultiKeyModels_PreservesOtherFields(t *testing.T) { if primary.ThinkingLevel != "high" { t.Errorf("expected thinking_level preserved, got %q", primary.ThinkingLevel) } + if primary.ToolSchemaTransform != "simple" { + t.Errorf("expected tool_schema_transform preserved, got %q", primary.ToolSchemaTransform) + } // Check additional entry also preserves fields additional := result[0] @@ -237,6 +241,9 @@ func TestExpandMultiKeyModels_PreservesOtherFields(t *testing.T) { if additional.RPM != 60 { t.Errorf("expected additional rpm preserved, got %d", additional.RPM) } + if additional.ToolSchemaTransform != "simple" { + t.Errorf("expected additional tool_schema_transform preserved, got %q", additional.ToolSchemaTransform) + } } func TestExpandMultiKeyModels_IsVirtualFlag(t *testing.T) { diff --git a/pkg/providers/common/google_schema.go b/pkg/providers/common/google_schema.go index bdafadd23..f7b2a337b 100644 --- a/pkg/providers/common/google_schema.go +++ b/pkg/providers/common/google_schema.go @@ -16,11 +16,11 @@ var geminiSupportedTypes = map[string]bool{ "string": true, } -// SanitizeSchemaForGemini reduces a JSON Schema to the conservative subset -// accepted by Gemini-style function declarations. It resolves local refs, -// collapses composition keywords like anyOf/oneOf/allOf, and strips advanced -// keywords that Gemini rejects. -func SanitizeSchemaForGemini(schema map[string]any) map[string]any { +// SanitizeSchemaForGoogle reduces a JSON Schema to the conservative subset +// accepted by Google/Gemini-style function declarations. It resolves local +// refs, collapses composition keywords like anyOf/oneOf/allOf, and strips +// advanced keywords that Gemini-compatible backends often reject. +func SanitizeSchemaForGoogle(schema map[string]any) map[string]any { if schema == nil { return nil } @@ -39,6 +39,12 @@ func SanitizeSchemaForGemini(schema map[string]any) map[string]any { return result } +// SanitizeSchemaForGemini is kept as a compatibility alias for the original +// Google/Gemini sanitizer name. +func SanitizeSchemaForGemini(schema map[string]any) map[string]any { + return SanitizeSchemaForGoogle(schema) +} + type geminiSchemaSanitizer struct { root map[string]any } diff --git a/pkg/providers/common/tool_schema_transform.go b/pkg/providers/common/tool_schema_transform.go new file mode 100644 index 000000000..10e96d056 --- /dev/null +++ b/pkg/providers/common/tool_schema_transform.go @@ -0,0 +1,59 @@ +package common + +import ( + "fmt" + "strings" +) + +const ( + ToolSchemaTransformOff = "" + ToolSchemaTransformSimple = "simple" +) + +// NormalizeToolSchemaTransform resolves user-facing aliases to a canonical +// transform mode. Empty values and explicit "off"-style values disable schema +// transformation. +func NormalizeToolSchemaTransform(raw string) (string, error) { + switch strings.ToLower(strings.TrimSpace(raw)) { + case "", "off", "none", "native": + return ToolSchemaTransformOff, nil + case "simple", "basic", "strict", "flat": + return ToolSchemaTransformSimple, nil + default: + return "", fmt.Errorf("unsupported tool_schema_transform %q (supported: off, simple)", raw) + } +} + +// TransformToolDefinitions clones tool definitions and applies the configured +// schema transform to function parameter schemas. When the transform is off, the +// original slice is returned unchanged. +func TransformToolDefinitions(tools []ToolDefinition, transform string) ([]ToolDefinition, error) { + transform, err := NormalizeToolSchemaTransform(transform) + if err != nil { + return nil, err + } + if transform == ToolSchemaTransformOff || len(tools) == 0 { + return tools, nil + } + + out := make([]ToolDefinition, len(tools)) + for i, tool := range tools { + out[i] = tool + if tool.Type != "function" { + continue + } + out[i].Function = tool.Function + out[i].Function.Parameters = transformToolSchema(tool.Function.Parameters, transform) + } + + return out, nil +} + +func transformToolSchema(schema map[string]any, transform string) map[string]any { + switch transform { + case ToolSchemaTransformSimple: + return SanitizeSchemaForGoogle(schema) + default: + return cloneGeminiSchemaMap(schema) + } +} diff --git a/pkg/providers/factory_provider.go b/pkg/providers/factory_provider.go index ce83c6c54..a59e2de25 100644 --- a/pkg/providers/factory_provider.go +++ b/pkg/providers/factory_provider.go @@ -168,7 +168,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if err != nil { return nil, "", err } - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) } // OpenAI with API key if cfg.APIKey() == "" && cfg.APIBase == "" { @@ -189,7 +189,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err cfg.CustomHeaders, ) provider.SetProviderName(protocol) - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) case "azure", "azure-openai": // Azure OpenAI uses deployment-based URLs, api-key header auth, @@ -202,13 +202,13 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err "api_base is required for azure protocol (e.g., https://your-resource.openai.azure.com)", ) } - return azure.NewProviderWithTimeout( + return finalizeProviderFromConfig(azure.NewProviderWithTimeout( cfg.APIKey(), cfg.APIBase, cfg.Proxy, userAgent, cfg.RequestTimeout, - ), modelID, nil + ), modelID, cfg) case "bedrock": // AWS Bedrock uses AWS SDK credentials (env vars, profiles, IAM roles, etc.) @@ -244,7 +244,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if err != nil { return nil, "", fmt.Errorf("creating bedrock provider: %w", err) } - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) case "litellm", "lmstudio", "openrouter", "groq", "zhipu", "nvidia", "venice", "ollama", "moonshot", "shengsuanyun", "deepseek", "cerebras", @@ -270,7 +270,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err cfg.CustomHeaders, ) provider.SetProviderName(protocol) - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) case "gemini": if cfg.APIKey() == "" && cfg.APIBase == "" { @@ -280,7 +280,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if apiBase == "" { apiBase = getDefaultAPIBase(protocol) } - return NewGeminiProvider( + return finalizeProviderFromConfig(NewGeminiProvider( cfg.APIKey(), apiBase, cfg.Proxy, @@ -288,7 +288,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err cfg.RequestTimeout, cfg.ExtraBody, cfg.CustomHeaders, - ), modelID, nil + ), modelID, cfg) case "minimax": // Minimax requires reasoning_split: true in the request body @@ -317,7 +317,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err cfg.CustomHeaders, ) provider.SetProviderName(protocol) - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) case "anthropic": if cfg.AuthMethod == "oauth" || cfg.AuthMethod == "token" { @@ -326,7 +326,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if err != nil { return nil, "", err } - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) } // Use API key with HTTP API apiBase := cfg.APIBase @@ -347,7 +347,7 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err cfg.CustomHeaders, ) provider.SetProviderName(protocol) - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) case "anthropic-messages": // Anthropic Messages API with native format (HTTP-based, no SDK) @@ -358,12 +358,12 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if cfg.APIKey() == "" { return nil, "", fmt.Errorf("api_key is required for anthropic-messages protocol (model: %s)", cfg.Model) } - return anthropicmessages.NewProviderWithTimeout( + return finalizeProviderFromConfig(anthropicmessages.NewProviderWithTimeout( cfg.APIKey(), apiBase, userAgent, cfg.RequestTimeout, - ), modelID, nil + ), modelID, cfg) case "coding-plan-anthropic", "alibaba-coding-anthropic": // Alibaba Coding Plan with Anthropic-compatible API @@ -374,29 +374,29 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if cfg.APIKey() == "" { return nil, "", fmt.Errorf("api_key is required for %q protocol (model: %s)", protocol, cfg.Model) } - return anthropicmessages.NewProviderWithTimeout( + return finalizeProviderFromConfig(anthropicmessages.NewProviderWithTimeout( cfg.APIKey(), apiBase, userAgent, cfg.RequestTimeout, - ), modelID, nil + ), modelID, cfg) case "antigravity": - return NewAntigravityProvider(), modelID, nil + return finalizeProviderFromConfig(NewAntigravityProvider(), modelID, cfg) case "claude-cli", "claudecli": workspace := cfg.Workspace if workspace == "" { workspace = "." } - return NewClaudeCliProvider(workspace), modelID, nil + return finalizeProviderFromConfig(NewClaudeCliProvider(workspace), modelID, cfg) case "codex-cli", "codexcli": workspace := cfg.Workspace if workspace == "" { workspace = "." } - return NewCodexCliProvider(workspace), modelID, nil + return finalizeProviderFromConfig(NewCodexCliProvider(workspace), modelID, cfg) case "github-copilot", "copilot": apiBase := cfg.APIBase @@ -411,13 +411,25 @@ func CreateProviderFromConfig(cfg *config.ModelConfig) (LLMProvider, string, err if err != nil { return nil, "", err } - return provider, modelID, nil + return finalizeProviderFromConfig(provider, modelID, cfg) default: return nil, "", fmt.Errorf("unknown protocol %q in model %q", protocol, cfg.Model) } } +func finalizeProviderFromConfig( + provider LLMProvider, + modelID string, + cfg *config.ModelConfig, +) (LLMProvider, string, error) { + wrapped, err := wrapProviderWithToolSchemaTransform(provider, cfg.ToolSchemaTransform) + if err != nil { + return nil, "", err + } + return wrapped, modelID, nil +} + func isEmptyAPIKeyAllowed(protocol string) bool { meta, ok := protocolMetaByName[protocol] return ok && meta.emptyAPIKeyAllowed diff --git a/pkg/providers/factory_provider_test.go b/pkg/providers/factory_provider_test.go index 3dd1eefb3..3d3c30ce0 100644 --- a/pkg/providers/factory_provider_test.go +++ b/pkg/providers/factory_provider_test.go @@ -1202,3 +1202,42 @@ func TestCreateProviderFromConfig_BedrockWithEndpointURL(t *testing.T) { // Unexpected error - fail the test t.Errorf("unexpected error from bedrock provider: %v", err) } + +func TestCreateProviderFromConfig_ToolSchemaTransformWrapsProvider(t *testing.T) { + cfg := &config.ModelConfig{ + ModelName: "claude-cli-test", + Provider: "claude-cli", + Model: "claude-sonnet-4.6", + Workspace: t.TempDir(), + ToolSchemaTransform: "simple", + } + + provider, modelID, err := CreateProviderFromConfig(cfg) + if err != nil { + t.Fatalf("CreateProviderFromConfig() error = %v", err) + } + if modelID != "claude-sonnet-4.6" { + t.Fatalf("modelID = %q, want %q", modelID, "claude-sonnet-4.6") + } + if _, ok := provider.(*toolSchemaTransformProvider); !ok { + t.Fatalf("provider = %T, want *toolSchemaTransformProvider", provider) + } +} + +func TestCreateProviderFromConfig_InvalidToolSchemaTransform(t *testing.T) { + cfg := &config.ModelConfig{ + ModelName: "claude-cli-test", + Provider: "claude-cli", + Model: "claude-sonnet-4.6", + Workspace: t.TempDir(), + ToolSchemaTransform: "invalid", + } + + _, _, err := CreateProviderFromConfig(cfg) + if err == nil { + t.Fatal("CreateProviderFromConfig() expected error for invalid tool_schema_transform") + } + if !strings.Contains(err.Error(), "tool_schema_transform") { + t.Fatalf("error = %v, want mention tool_schema_transform", err) + } +} diff --git a/pkg/providers/httpapi/gemini_provider.go b/pkg/providers/httpapi/gemini_provider.go index e73568c88..395c555d1 100644 --- a/pkg/providers/httpapi/gemini_provider.go +++ b/pkg/providers/httpapi/gemini_provider.go @@ -264,7 +264,7 @@ func (p *GeminiProvider) buildRequestBody( funcDecls = append(funcDecls, geminiFunctionDeclaration{ Name: t.Function.Name, Description: t.Function.Description, - Parameters: common.SanitizeSchemaForGemini(t.Function.Parameters), + Parameters: t.Function.Parameters, }) } if len(funcDecls) > 0 { diff --git a/pkg/providers/httpapi/gemini_provider_test.go b/pkg/providers/httpapi/gemini_provider_test.go index 53770511e..b455357c0 100644 --- a/pkg/providers/httpapi/gemini_provider_test.go +++ b/pkg/providers/httpapi/gemini_provider_test.go @@ -5,11 +5,8 @@ import ( "fmt" "net/http" "net/http/httptest" - "reflect" "strings" "testing" - - providercommon "github.com/sipeed/picoclaw/pkg/providers/common" ) func TestGeminiProvider_ChatSeparatesThoughtAndToolCall(t *testing.T) { @@ -262,7 +259,7 @@ func TestGeminiProvider_ChatStreamSkipsEmptyDataFrames(t *testing.T) { } } -func TestGeminiProvider_BuildRequestBody_SanitizesComplexToolSchemas(t *testing.T) { +func TestGeminiProvider_BuildRequestBody_PreservesComplexToolSchemasByDefault(t *testing.T) { provider := NewGeminiProvider("test-key", "https://example.com/v1beta", "", "", 0, nil, nil) schema := map[string]any{ "type": "object", @@ -315,9 +312,8 @@ func TestGeminiProvider_BuildRequestBody_SanitizesComplexToolSchemas(t *testing. t.Fatalf("parameters = %#v, want map", tools[0].FunctionDeclarations[0].Parameters) } - want := providercommon.SanitizeSchemaForGemini(schema) - if !reflect.DeepEqual(got, want) { - t.Fatalf("sanitized parameters mismatch\n got: %#v\nwant: %#v", got, want) + if got["$defs"] == nil { + t.Fatalf("parameters = %#v, want raw schema with $defs preserved by default", got) } } diff --git a/pkg/providers/oauth/antigravity_provider.go b/pkg/providers/oauth/antigravity_provider.go index fd5431b03..abf1e4bd6 100644 --- a/pkg/providers/oauth/antigravity_provider.go +++ b/pkg/providers/oauth/antigravity_provider.go @@ -291,18 +291,17 @@ func (p *AntigravityProvider) buildRequest( } } - // Build tools (sanitize schemas for Gemini compatibility) + // Build tools if len(tools) > 0 { var funcDecls []antigravityFuncDecl for _, t := range tools { if t.Type != "function" { continue } - params := common.SanitizeSchemaForGemini(t.Function.Parameters) funcDecls = append(funcDecls, antigravityFuncDecl{ Name: t.Function.Name, Description: t.Function.Description, - Parameters: params, + Parameters: t.Function.Parameters, }) } if len(funcDecls) > 0 { diff --git a/pkg/providers/oauth/antigravity_provider_test.go b/pkg/providers/oauth/antigravity_provider_test.go index 015b1ab80..d85e47dfa 100644 --- a/pkg/providers/oauth/antigravity_provider_test.go +++ b/pkg/providers/oauth/antigravity_provider_test.go @@ -1,10 +1,7 @@ package oauthprovider import ( - "reflect" "testing" - - providercommon "github.com/sipeed/picoclaw/pkg/providers/common" ) func TestBuildRequestUsesFunctionFieldsWhenToolCallNameMissing(t *testing.T) { @@ -77,7 +74,7 @@ func TestParseSSEResponse_SplitsThoughtAndVisibleContent(t *testing.T) { } } -func TestBuildRequest_SanitizesComplexToolSchemas(t *testing.T) { +func TestBuildRequest_PreservesComplexToolSchemasByDefault(t *testing.T) { p := &AntigravityProvider{} schema := map[string]any{ "type": "object", @@ -135,9 +132,11 @@ func TestBuildRequest_SanitizesComplexToolSchemas(t *testing.T) { t.Fatalf("request tools = %#v, want one function declaration", req.Tools) } - got := req.Tools[0].FunctionDeclarations[0].Parameters - want := providercommon.SanitizeSchemaForGemini(schema) - if !reflect.DeepEqual(got, want) { - t.Fatalf("sanitized parameters mismatch\n got: %#v\nwant: %#v", got, want) + got, ok := req.Tools[0].FunctionDeclarations[0].Parameters.(map[string]any) + if !ok { + t.Fatalf("parameters = %#v, want map", req.Tools[0].FunctionDeclarations[0].Parameters) + } + if got["$defs"] == nil { + t.Fatalf("parameters = %#v, want raw schema with $defs preserved by default", got) } } diff --git a/pkg/providers/tool_schema_transform.go b/pkg/providers/tool_schema_transform.go new file mode 100644 index 000000000..6b6cab7a6 --- /dev/null +++ b/pkg/providers/tool_schema_transform.go @@ -0,0 +1,84 @@ +package providers + +import ( + "context" + + "github.com/sipeed/picoclaw/pkg/providers/common" +) + +type toolSchemaTransformProvider struct { + delegate LLMProvider + transform string +} + +type toolSchemaStreamingProvider struct { + *toolSchemaTransformProvider +} + +func wrapProviderWithToolSchemaTransform(delegate LLMProvider, transform string) (LLMProvider, error) { + transform, err := common.NormalizeToolSchemaTransform(transform) + if err != nil { + return nil, err + } + if transform == common.ToolSchemaTransformOff || delegate == nil { + return delegate, nil + } + base := &toolSchemaTransformProvider{ + delegate: delegate, + transform: transform, + } + if _, ok := delegate.(StreamingProvider); ok { + return &toolSchemaStreamingProvider{toolSchemaTransformProvider: base}, nil + } + return base, nil +} + +func (p *toolSchemaTransformProvider) Chat( + ctx context.Context, + messages []Message, + tools []ToolDefinition, + model string, + options map[string]any, +) (*LLMResponse, error) { + transformed, err := common.TransformToolDefinitions(tools, p.transform) + if err != nil { + return nil, err + } + return p.delegate.Chat(ctx, messages, transformed, model, options) +} + +func (p *toolSchemaTransformProvider) GetDefaultModel() string { + return p.delegate.GetDefaultModel() +} + +func (p *toolSchemaStreamingProvider) ChatStream( + ctx context.Context, + messages []Message, + tools []ToolDefinition, + model string, + options map[string]any, + onChunk func(accumulated string), +) (*LLMResponse, error) { + streaming := p.delegate.(StreamingProvider) + transformed, err := common.TransformToolDefinitions(tools, p.transform) + if err != nil { + return nil, err + } + return streaming.ChatStream(ctx, messages, transformed, model, options, onChunk) +} + +func (p *toolSchemaTransformProvider) SupportsThinking() bool { + tc, ok := p.delegate.(ThinkingCapable) + return ok && tc.SupportsThinking() +} + +func (p *toolSchemaTransformProvider) SupportsNativeSearch() bool { + ns, ok := p.delegate.(NativeSearchCapable) + return ok && ns.SupportsNativeSearch() +} + +func (p *toolSchemaTransformProvider) Close() { + if stateful, ok := p.delegate.(StatefulProvider); ok { + stateful.Close() + } +} diff --git a/pkg/providers/tool_schema_transform_test.go b/pkg/providers/tool_schema_transform_test.go new file mode 100644 index 000000000..c83416377 --- /dev/null +++ b/pkg/providers/tool_schema_transform_test.go @@ -0,0 +1,104 @@ +package providers + +import ( + "context" + "reflect" + "testing" + + providercommon "github.com/sipeed/picoclaw/pkg/providers/common" +) + +type toolCaptureProvider struct { + lastTools []ToolDefinition +} + +func (p *toolCaptureProvider) Chat( + _ context.Context, + _ []Message, + tools []ToolDefinition, + _ string, + _ map[string]any, +) (*LLMResponse, error) { + p.lastTools = tools + return &LLMResponse{Content: "ok"}, nil +} + +func (p *toolCaptureProvider) GetDefaultModel() string { + return "test" +} + +func TestWrapProviderWithToolSchemaTransform_DisabledPassesToolsThrough(t *testing.T) { + capture := &toolCaptureProvider{} + wrapped, err := wrapProviderWithToolSchemaTransform(capture, "") + if err != nil { + t.Fatalf("wrapProviderWithToolSchemaTransform() error = %v", err) + } + + tools := []ToolDefinition{{ + Type: "function", + Function: ToolFunctionDefinition{ + Name: "noop", + Parameters: map[string]any{"type": "object"}, + }, + }} + + _, err = wrapped.Chat(t.Context(), nil, tools, "test", nil) + if err != nil { + t.Fatalf("Chat() error = %v", err) + } + if !reflect.DeepEqual(capture.lastTools, tools) { + t.Fatalf("tools mutated with transform off\n got: %#v\nwant: %#v", capture.lastTools, tools) + } +} + +func TestWrapProviderWithToolSchemaTransform_GoogleSanitizesSchemas(t *testing.T) { + capture := &toolCaptureProvider{} + wrapped, err := wrapProviderWithToolSchemaTransform(capture, "google") + if err != nil { + t.Fatalf("wrapProviderWithToolSchemaTransform() error = %v", err) + } + + schema := map[string]any{ + "type": "object", + "properties": map[string]any{ + "parent": map[string]any{ + "anyOf": []any{ + map[string]any{"$ref": "#/$defs/pageParent"}, + map[string]any{"$ref": "#/$defs/databaseParent"}, + }, + }, + }, + "$defs": map[string]any{ + "pageParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "page_id": map[string]any{"type": "string"}, + }, + }, + "databaseParent": map[string]any{ + "type": "object", + "properties": map[string]any{ + "database_id": map[string]any{"type": "string"}, + }, + }, + }, + } + tools := []ToolDefinition{{ + Type: "function", + Function: ToolFunctionDefinition{ + Name: "mcp_notion_create", + Parameters: schema, + }, + }} + + _, err = wrapped.Chat(t.Context(), nil, tools, "test", nil) + if err != nil { + t.Fatalf("Chat() error = %v", err) + } + + want := providercommon.SanitizeSchemaForGoogle(schema) + got := capture.lastTools[0].Function.Parameters + if !reflect.DeepEqual(got, want) { + t.Fatalf("sanitized parameters mismatch\n got: %#v\nwant: %#v", got, want) + } +} diff --git a/web/backend/api/models.go b/web/backend/api/models.go index cf903ce4c..61eb235cb 100644 --- a/web/backend/api/models.go +++ b/web/backend/api/models.go @@ -35,14 +35,15 @@ type modelResponse struct { Proxy string `json:"proxy,omitempty"` AuthMethod string `json:"auth_method,omitempty"` // Advanced fields - ConnectMode string `json:"connect_mode,omitempty"` - Workspace string `json:"workspace,omitempty"` - RPM int `json:"rpm,omitempty"` - MaxTokensField string `json:"max_tokens_field,omitempty"` - RequestTimeout int `json:"request_timeout,omitempty"` - ThinkingLevel string `json:"thinking_level,omitempty"` - ExtraBody map[string]any `json:"extra_body,omitempty"` - CustomHeaders map[string]string `json:"custom_headers,omitempty"` + ConnectMode string `json:"connect_mode,omitempty"` + Workspace string `json:"workspace,omitempty"` + RPM int `json:"rpm,omitempty"` + MaxTokensField string `json:"max_tokens_field,omitempty"` + RequestTimeout int `json:"request_timeout,omitempty"` + ThinkingLevel string `json:"thinking_level,omitempty"` + ToolSchemaTransform string `json:"tool_schema_transform,omitempty"` + ExtraBody map[string]any `json:"extra_body,omitempty"` + CustomHeaders map[string]string `json:"custom_headers,omitempty"` // Meta Enabled bool `json:"enabled"` Available bool `json:"available"` @@ -78,27 +79,28 @@ func (h *Handler) handleListModels(w http.ResponseWriter, r *http.Request) { for i, m := range cfg.ModelList { provider, modelID := providers.ExtractProtocol(m) models = append(models, modelResponse{ - Index: i, - ModelName: m.ModelName, - Provider: provider, - Model: modelID, - APIBase: m.APIBase, - APIKey: maskAPIKey(m.APIKey()), - Proxy: m.Proxy, - AuthMethod: m.AuthMethod, - ConnectMode: m.ConnectMode, - Workspace: m.Workspace, - RPM: m.RPM, - MaxTokensField: m.MaxTokensField, - RequestTimeout: m.RequestTimeout, - ThinkingLevel: m.ThinkingLevel, - ExtraBody: m.ExtraBody, - CustomHeaders: m.CustomHeaders, - Enabled: m.Enabled, - Available: modelStatuses[i].Available, - Status: modelStatuses[i].Status, - IsDefault: m.ModelName == defaultModel, - IsVirtual: m.IsVirtual(), + Index: i, + ModelName: m.ModelName, + Provider: provider, + Model: modelID, + APIBase: m.APIBase, + APIKey: maskAPIKey(m.APIKey()), + Proxy: m.Proxy, + AuthMethod: m.AuthMethod, + ConnectMode: m.ConnectMode, + Workspace: m.Workspace, + RPM: m.RPM, + MaxTokensField: m.MaxTokensField, + RequestTimeout: m.RequestTimeout, + ThinkingLevel: m.ThinkingLevel, + ToolSchemaTransform: m.ToolSchemaTransform, + ExtraBody: m.ExtraBody, + CustomHeaders: m.CustomHeaders, + Enabled: m.Enabled, + Available: modelStatuses[i].Available, + Status: modelStatuses[i].Status, + IsDefault: m.ModelName == defaultModel, + IsVirtual: m.IsVirtual(), }) } @@ -237,6 +239,9 @@ func (h *Handler) handleUpdateModel(w http.ResponseWriter, r *http.Request) { } else if len(mc.CustomHeaders) == 0 { mc.CustomHeaders = nil } + if _, ok := rawFields["tool_schema_transform"]; !ok { + mc.ToolSchemaTransform = cfg.ModelList[idx].ToolSchemaTransform + } // Preserve the existing Provider when the caller omits it. This keeps the // update API backward-compatible for clients that haven't started sending // the new field yet, while still allowing explicit clearing via "". diff --git a/web/backend/api/models_test.go b/web/backend/api/models_test.go index f374ac15b..a60c6ef7a 100644 --- a/web/backend/api/models_test.go +++ b/web/backend/api/models_test.go @@ -584,6 +584,37 @@ func TestHandleAddModel_PersistsCustomHeaders(t *testing.T) { } } +func TestHandleAddModel_PersistsToolSchemaTransform(t *testing.T) { + configPath, cleanup := setupOAuthTestEnv(t) + defer cleanup() + + h := NewHandler(configPath) + mux := http.NewServeMux() + h.RegisterRoutes(mux) + + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/api/models", bytes.NewBufferString(`{ + "model_name":"new-model-transform", + "model":"openai/gpt-4o-mini", + "tool_schema_transform":"simple" + }`)) + req.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want %d, body=%s", rec.Code, http.StatusOK, rec.Body.String()) + } + + cfg, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() error = %v", err) + } + added := cfg.ModelList[len(cfg.ModelList)-1] + if got := added.ToolSchemaTransform; got != "simple" { + t.Fatalf("tool_schema_transform = %q, want %q", got, "simple") + } +} + func TestHandleUpdateModel_CustomHeadersPreserveAndClear(t *testing.T) { configPath, cleanup := setupOAuthTestEnv(t) defer cleanup() @@ -649,6 +680,69 @@ func TestHandleUpdateModel_CustomHeadersPreserveAndClear(t *testing.T) { } } +func TestHandleUpdateModel_ToolSchemaTransformPreserveAndClear(t *testing.T) { + configPath, cleanup := setupOAuthTestEnv(t) + defer cleanup() + + cfg, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() error = %v", err) + } + cfg.ModelList = []*config.ModelConfig{{ + ModelName: "editable", + Model: "openai/gpt-4o-mini", + APIKeys: config.SimpleSecureStrings("sk-existing"), + ToolSchemaTransform: "google", + }} + err = config.SaveConfig(configPath, cfg) + if err != nil { + t.Fatalf("SaveConfig() error = %v", err) + } + + h := NewHandler(configPath) + mux := http.NewServeMux() + h.RegisterRoutes(mux) + + recPreserve := httptest.NewRecorder() + reqPreserve := httptest.NewRequest(http.MethodPut, "/api/models/0", bytes.NewBufferString(`{ + "model_name":"editable", + "model":"openai/gpt-4o-mini" + }`)) + reqPreserve.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(recPreserve, reqPreserve) + if recPreserve.Code != http.StatusOK { + t.Fatalf("preserve status = %d, want %d, body=%s", recPreserve.Code, http.StatusOK, recPreserve.Body.String()) + } + + afterPreserve, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() after preserve error = %v", err) + } + if got := afterPreserve.ModelList[0].ToolSchemaTransform; got != "google" { + t.Fatalf("preserved tool_schema_transform = %q, want %q", got, "google") + } + + recClear := httptest.NewRecorder() + reqClear := httptest.NewRequest(http.MethodPut, "/api/models/0", bytes.NewBufferString(`{ + "model_name":"editable", + "model":"openai/gpt-4o-mini", + "tool_schema_transform":"" + }`)) + reqClear.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(recClear, reqClear) + if recClear.Code != http.StatusOK { + t.Fatalf("clear status = %d, want %d, body=%s", recClear.Code, http.StatusOK, recClear.Body.String()) + } + + afterClear, err := config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig() after clear error = %v", err) + } + if afterClear.ModelList[0].ToolSchemaTransform != "" { + t.Fatalf("tool_schema_transform = %q, want empty", afterClear.ModelList[0].ToolSchemaTransform) + } +} + func TestHandleUpdateModel_PersistsProvider(t *testing.T) { configPath, cleanup := setupOAuthTestEnv(t) defer cleanup() diff --git a/web/frontend/src/api/models.ts b/web/frontend/src/api/models.ts index d2d2dca88..926bf8a0a 100644 --- a/web/frontend/src/api/models.ts +++ b/web/frontend/src/api/models.ts @@ -19,6 +19,7 @@ export interface ModelInfo { max_tokens_field?: string request_timeout?: number thinking_level?: string + tool_schema_transform?: string extra_body?: Record custom_headers?: Record // Meta diff --git a/web/frontend/src/components/models/add-model-sheet.tsx b/web/frontend/src/components/models/add-model-sheet.tsx index a9102aa8a..be2a8fd64 100644 --- a/web/frontend/src/components/models/add-model-sheet.tsx +++ b/web/frontend/src/components/models/add-model-sheet.tsx @@ -36,6 +36,7 @@ interface AddForm { maxTokensField: string requestTimeout: string thinkingLevel: string + toolSchemaTransform: string extraBody: string customHeaders: string } @@ -54,6 +55,7 @@ const EMPTY_ADD_FORM: AddForm = { maxTokensField: "", requestTimeout: "", thinkingLevel: "", + toolSchemaTransform: "", extraBody: "", customHeaders: "", } @@ -139,6 +141,7 @@ export function AddModelSheet({ ? Number(form.requestTimeout) : undefined, thinking_level: form.thinkingLevel.trim() || undefined, + tool_schema_transform: form.toolSchemaTransform.trim() || undefined, extra_body: form.extraBody.trim() ? JSON.parse(form.extraBody.trim()) : undefined, @@ -333,6 +336,17 @@ export function AddModelSheet({ /> + + + + + + + + Date: Mon, 27 Apr 2026 21:18:19 +0200 Subject: [PATCH 35/53] fix test --- pkg/providers/tool_schema_transform_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/providers/tool_schema_transform_test.go b/pkg/providers/tool_schema_transform_test.go index c83416377..a162c3cb4 100644 --- a/pkg/providers/tool_schema_transform_test.go +++ b/pkg/providers/tool_schema_transform_test.go @@ -53,7 +53,7 @@ func TestWrapProviderWithToolSchemaTransform_DisabledPassesToolsThrough(t *testi func TestWrapProviderWithToolSchemaTransform_GoogleSanitizesSchemas(t *testing.T) { capture := &toolCaptureProvider{} - wrapped, err := wrapProviderWithToolSchemaTransform(capture, "google") + wrapped, err := wrapProviderWithToolSchemaTransform(capture, "simple") if err != nil { t.Fatalf("wrapProviderWithToolSchemaTransform() error = %v", err) } From 23df824c776334317aae2cbcf9c6ff3a26695fe2 Mon Sep 17 00:00:00 2001 From: afjcjsbx Date: Mon, 27 Apr 2026 21:27:02 +0200 Subject: [PATCH 36/53] fix test --- web/backend/api/models_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/web/backend/api/models_test.go b/web/backend/api/models_test.go index a60c6ef7a..dd5ff6a54 100644 --- a/web/backend/api/models_test.go +++ b/web/backend/api/models_test.go @@ -692,7 +692,7 @@ func TestHandleUpdateModel_ToolSchemaTransformPreserveAndClear(t *testing.T) { ModelName: "editable", Model: "openai/gpt-4o-mini", APIKeys: config.SimpleSecureStrings("sk-existing"), - ToolSchemaTransform: "google", + ToolSchemaTransform: "simple", }} err = config.SaveConfig(configPath, cfg) if err != nil { @@ -718,8 +718,8 @@ func TestHandleUpdateModel_ToolSchemaTransformPreserveAndClear(t *testing.T) { if err != nil { t.Fatalf("LoadConfig() after preserve error = %v", err) } - if got := afterPreserve.ModelList[0].ToolSchemaTransform; got != "google" { - t.Fatalf("preserved tool_schema_transform = %q, want %q", got, "google") + if got := afterPreserve.ModelList[0].ToolSchemaTransform; got != "simple" { + t.Fatalf("preserved tool_schema_transform = %q, want %q", got, "simple") } recClear := httptest.NewRecorder() From 1722cfc28222f5259a717a52aaeb63b0a44c1a5c Mon Sep 17 00:00:00 2001 From: LiusCraft Date: Thu, 30 Apr 2026 02:24:29 +0800 Subject: [PATCH 37/53] feat: add DeepSeek vision unsupported error detection Add detection for 'unknown variant' + 'image_url' error pattern used by DeepSeek and other strict providers when vision is not supported. These providers reject the image_url field at the JSON schema level rather than returning a semantic 'not supported' message. --- pkg/agent/llm_media.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pkg/agent/llm_media.go b/pkg/agent/llm_media.go index eb1908777..31692174b 100644 --- a/pkg/agent/llm_media.go +++ b/pkg/agent/llm_media.go @@ -56,5 +56,12 @@ func isVisionUnsupportedError(err error) bool { return true } + // DeepSeek and other strict providers reject the image_url field at the + // JSON schema level with an "unknown variant" error rather than a semantic + // "not supported" message. + if strings.Contains(msg, "unknown variant") && strings.Contains(msg, "image_url") { + return true + } + return false } From a7414608edb7c30aa70b1ee676d7de4c0edfa989 Mon Sep 17 00:00:00 2001 From: lxowalle <83055338+lxowalle@users.noreply.github.com> Date: Thu, 30 Apr 2026 18:04:48 +0800 Subject: [PATCH 38/53] * fix build failed (#2723) --- .github/workflows/nightly.yml | 16 +++++++++++----- .github/workflows/release.yml | 16 +++++++++++----- 2 files changed, 22 insertions(+), 10 deletions(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index d507234dc..f595004f0 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -235,25 +235,31 @@ jobs: MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }} MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }} run: | - pip3 install rcodesign + cleanup() { + rm -rf .venv-rcodesign + rm -f cert.p12 notary-key.p8 + } + trap cleanup EXIT + + python3 -m venv .venv-rcodesign + ./.venv-rcodesign/bin/python -m pip install --upgrade pip + ./.venv-rcodesign/bin/python -m pip install rcodesign echo "$MACOS_SIGN_P12" | base64 -d > cert.p12 - rcodesign sign \ + ./.venv-rcodesign/bin/rcodesign sign \ --p12-file cert.p12 \ --p12-password "$MACOS_SIGN_PASSWORD" \ picoclaw-launcher-cgo echo "$MACOS_NOTARY_KEY" > notary-key.p8 - rcodesign notary-submit \ + ./.venv-rcodesign/bin/rcodesign notary-submit \ --api-key-path notary-key.p8 \ --api-issuer "$MACOS_NOTARY_ISSUER_ID" \ --wait \ picoclaw-launcher-cgo - rm -f cert.p12 notary-key.p8 - - name: Upload launcher artifact uses: actions/upload-artifact@v4 with: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 9aa054943..e781474f8 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -194,25 +194,31 @@ jobs: MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }} MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }} run: | - pip3 install rcodesign + cleanup() { + rm -rf .venv-rcodesign + rm -f cert.p12 notary-key.p8 + } + trap cleanup EXIT + + python3 -m venv .venv-rcodesign + ./.venv-rcodesign/bin/python -m pip install --upgrade pip + ./.venv-rcodesign/bin/python -m pip install rcodesign echo "$MACOS_SIGN_P12" | base64 -d > cert.p12 - rcodesign sign \ + ./.venv-rcodesign/bin/rcodesign sign \ --p12-file cert.p12 \ --p12-password "$MACOS_SIGN_PASSWORD" \ picoclaw-launcher-cgo echo "$MACOS_NOTARY_KEY" > notary-key.p8 - rcodesign notary-submit \ + ./.venv-rcodesign/bin/rcodesign notary-submit \ --api-key-path notary-key.p8 \ --api-issuer "$MACOS_NOTARY_ISSUER_ID" \ --wait \ picoclaw-launcher-cgo - rm -f cert.p12 notary-key.p8 - - name: Upload launcher artifact uses: actions/upload-artifact@v4 with: From 6e1fab80e2f1da03605565e2dce20019d6be256f Mon Sep 17 00:00:00 2001 From: lxowalle <83055338+lxowalle@users.noreply.github.com> Date: Thu, 30 Apr 2026 22:48:32 +0800 Subject: [PATCH 39/53] Fix/build macos launcher failed (#2724) * fix(release): drop stale launcher tui goreleaser target * * delete unused file --- .github/workflows/nightly.yml | 166 +--------------------------------- .github/workflows/release.yml | 157 +------------------------------- .goreleaser.yaml | 10 +- 3 files changed, 8 insertions(+), 325 deletions(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index f595004f0..39ad8810e 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -74,10 +74,7 @@ jobs: password: ${{ secrets.GITHUB_TOKEN }} - name: Login to Docker Hub - if: env.DOCKERHUB_USERNAME != '' uses: docker/login-action@v4 - env: - DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }} with: registry: docker.io username: ${{ secrets.DOCKERHUB_USERNAME }} @@ -89,10 +86,6 @@ jobs: - name: Create local tag for GoReleaser run: git tag "${{ steps.version.outputs.version }}" - - name: Lowercase owner for Docker tags - id: repo - run: echo "owner=$(echo '${{ github.repository_owner }}' | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_OUTPUT" - - name: Run GoReleaser uses: goreleaser/goreleaser-action@v7 with: @@ -101,7 +94,7 @@ jobs: args: release --clean env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - REPO_OWNER: ${{ steps.repo.outputs.owner }} + GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }} DOCKERHUB_IMAGE_NAME: ${{ vars.DOCKERHUB_REPOSITORY }} GOVERSION: ${{ steps.setup-go.outputs.go-version }} GORELEASER_CURRENT_TAG: ${{ steps.version.outputs.version }} @@ -151,160 +144,3 @@ jobs: --prerelease \ --latest=false \ "${ASSETS[@]}" - - build-macos-launcher: - name: Build macOS Launcher (${{ matrix.arch_name }}) - runs-on: macos-latest - permissions: - contents: read - strategy: - matrix: - include: - - goarch: arm64 - arch_name: arm64 - - goarch: amd64 - arch_name: x86_64 - steps: - - name: Checkout - uses: actions/checkout@v6 - with: - fetch-depth: 0 - - - name: Setup Go from go.mod - uses: actions/setup-go@v6 - with: - go-version-file: go.mod - - - name: Setup pnpm - uses: pnpm/action-setup@v6 - with: - version: 10.33.0 - run_install: false - - - name: Setup Node.js - uses: actions/setup-node@v6 - with: - node-version: 22 - cache: pnpm - cache-dependency-path: web/frontend/pnpm-lock.yaml - - - name: Build frontend - run: | - cd web/frontend - CI=true pnpm install --frozen-lockfile - pnpm build:backend - - - name: Compute version - id: version - run: | - DATE=$(date -u +%Y%m%d) - SHA=$(git rev-parse --short=8 HEAD) - BASE_VERSION=$(git describe --tags --match "v*" --exclude "*nightly*" --abbrev=0 2>/dev/null || true) - if [ -z "$BASE_VERSION" ] || [ "$BASE_VERSION" = "v0.0.0" ]; then - VERSION="v0.0.0-nightly.${DATE}.${SHA}" - else - VERSION="${BASE_VERSION}-nightly.${DATE}.${SHA}" - fi - echo "version=${VERSION}" >> "$GITHUB_OUTPUT" - - - name: Build picoclaw-launcher with CGO - env: - CGO_ENABLED: "1" - GOOS: darwin - GOARCH: ${{ matrix.goarch }} - run: | - SDK_PATH=$(xcrun --show-sdk-path) - export CGO_CFLAGS="-isysroot ${SDK_PATH} -mmacosx-version-min=11.0" - export CGO_LDFLAGS="-isysroot ${SDK_PATH}" - - go generate ./... - go build -tags "goolm,stdjson" \ - -ldflags "-s -w \ - -X github.com/sipeed/picoclaw/pkg/config.Version=${{ steps.version.outputs.version }} \ - -X github.com/sipeed/picoclaw/pkg/config.GitCommit=$(git rev-parse --short HEAD) \ - -X github.com/sipeed/picoclaw/pkg/config.BuildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \ - -o picoclaw-launcher-cgo \ - ./web/backend - - - name: Sign and notarize launcher binary - if: env.MACOS_SIGN_P12 != '' - env: - MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }} - MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }} - MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }} - MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }} - MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }} - run: | - cleanup() { - rm -rf .venv-rcodesign - rm -f cert.p12 notary-key.p8 - } - trap cleanup EXIT - - python3 -m venv .venv-rcodesign - ./.venv-rcodesign/bin/python -m pip install --upgrade pip - ./.venv-rcodesign/bin/python -m pip install rcodesign - - echo "$MACOS_SIGN_P12" | base64 -d > cert.p12 - - ./.venv-rcodesign/bin/rcodesign sign \ - --p12-file cert.p12 \ - --p12-password "$MACOS_SIGN_PASSWORD" \ - picoclaw-launcher-cgo - - echo "$MACOS_NOTARY_KEY" > notary-key.p8 - - ./.venv-rcodesign/bin/rcodesign notary-submit \ - --api-key-path notary-key.p8 \ - --api-issuer "$MACOS_NOTARY_ISSUER_ID" \ - --wait \ - picoclaw-launcher-cgo - - - name: Upload launcher artifact - uses: actions/upload-artifact@v4 - with: - name: macos-launcher-${{ matrix.arch_name }} - path: picoclaw-launcher-cgo - retention-days: 1 - - patch-macos-archives: - name: Patch macOS Archives - needs: [nightly, build-macos-launcher] - runs-on: ubuntu-latest - permissions: - contents: write - strategy: - matrix: - include: - - arch_name: arm64 - - arch_name: x86_64 - steps: - - name: Download launcher artifact - uses: actions/download-artifact@v4 - with: - name: macos-launcher-${{ matrix.arch_name }} - - - name: Patch darwin release archive - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: | - ARCHIVE_NAME="picoclaw_Darwin_${{ matrix.arch_name }}.tar.gz" - - gh release download nightly \ - --repo "${{ github.repository }}" \ - --pattern "${ARCHIVE_NAME}" \ - --dir ./patch-tmp - - mkdir -p ./patch-extracted - tar xzf "./patch-tmp/${ARCHIVE_NAME}" -C ./patch-extracted - - cp picoclaw-launcher-cgo ./patch-extracted/picoclaw-launcher - chmod +x ./patch-extracted/picoclaw-launcher - - tar czf "${ARCHIVE_NAME}" -C ./patch-extracted . - - gh release upload nightly \ - --repo "${{ github.repository }}" \ - "${ARCHIVE_NAME}" --clobber - - echo "✅ Patched ${ARCHIVE_NAME} with CGO launcher (systray enabled)" diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index e781474f8..a52b6df8f 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -80,10 +80,7 @@ jobs: password: ${{ secrets.GITHUB_TOKEN }} - name: Login to Docker Hub - if: env.DOCKERHUB_USERNAME != '' uses: docker/login-action@v4 - env: - DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }} with: registry: docker.io username: ${{ secrets.DOCKERHUB_USERNAME }} @@ -92,10 +89,6 @@ jobs: - name: Install zip run: sudo apt-get install -y zip - - name: Lowercase owner for Docker tags - id: repo - run: echo "owner=$(echo '${{ github.repository_owner }}' | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_OUTPUT" - - name: Run GoReleaser uses: goreleaser/goreleaser-action@v7 with: @@ -104,7 +97,7 @@ jobs: args: release --clean env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - REPO_OWNER: ${{ steps.repo.outputs.owner }} + GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }} DOCKERHUB_IMAGE_NAME: ${{ vars.DOCKERHUB_REPOSITORY }} GOVERSION: ${{ steps.setup-go.outputs.go-version }} INCLUDE_ANDROID_BUNDLE: "true" @@ -123,155 +116,9 @@ jobs: --draft=${{ inputs.draft }} \ --prerelease=${{ inputs.prerelease }} - build-macos-launcher: - name: Build macOS Launcher (${{ matrix.arch_name }}) - runs-on: macos-latest - permissions: - contents: read - strategy: - matrix: - include: - - goarch: arm64 - arch_name: arm64 - - goarch: amd64 - arch_name: x86_64 - steps: - - name: Checkout tag - uses: actions/checkout@v6 - with: - fetch-depth: 0 - ref: ${{ inputs.tag }} - - - name: Setup Go from go.mod - uses: actions/setup-go@v6 - with: - go-version-file: go.mod - - - name: Setup pnpm - uses: pnpm/action-setup@v6 - with: - version: 10.33.0 - run_install: false - - - name: Setup Node.js - uses: actions/setup-node@v6 - with: - node-version: 22 - cache: pnpm - cache-dependency-path: web/frontend/pnpm-lock.yaml - - - name: Build frontend - run: | - cd web/frontend - CI=true pnpm install --frozen-lockfile - pnpm build:backend - - - name: Build picoclaw-launcher with CGO - env: - CGO_ENABLED: "1" - GOOS: darwin - GOARCH: ${{ matrix.goarch }} - run: | - SDK_PATH=$(xcrun --show-sdk-path) - export CGO_CFLAGS="-isysroot ${SDK_PATH} -mmacosx-version-min=11.0" - export CGO_LDFLAGS="-isysroot ${SDK_PATH}" - - go generate ./... - go build -tags "goolm,stdjson" \ - -ldflags "-s -w \ - -X github.com/sipeed/picoclaw/pkg/config.Version=${{ inputs.tag }} \ - -X github.com/sipeed/picoclaw/pkg/config.GitCommit=$(git rev-parse --short HEAD) \ - -X github.com/sipeed/picoclaw/pkg/config.BuildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)" \ - -o picoclaw-launcher-cgo \ - ./web/backend - - - name: Sign and notarize launcher binary - if: env.MACOS_SIGN_P12 != '' - env: - MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }} - MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }} - MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }} - MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }} - MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }} - run: | - cleanup() { - rm -rf .venv-rcodesign - rm -f cert.p12 notary-key.p8 - } - trap cleanup EXIT - - python3 -m venv .venv-rcodesign - ./.venv-rcodesign/bin/python -m pip install --upgrade pip - ./.venv-rcodesign/bin/python -m pip install rcodesign - - echo "$MACOS_SIGN_P12" | base64 -d > cert.p12 - - ./.venv-rcodesign/bin/rcodesign sign \ - --p12-file cert.p12 \ - --p12-password "$MACOS_SIGN_PASSWORD" \ - picoclaw-launcher-cgo - - echo "$MACOS_NOTARY_KEY" > notary-key.p8 - - ./.venv-rcodesign/bin/rcodesign notary-submit \ - --api-key-path notary-key.p8 \ - --api-issuer "$MACOS_NOTARY_ISSUER_ID" \ - --wait \ - picoclaw-launcher-cgo - - - name: Upload launcher artifact - uses: actions/upload-artifact@v4 - with: - name: macos-launcher-${{ matrix.arch_name }} - path: picoclaw-launcher-cgo - retention-days: 1 - - patch-macos-archives: - name: Patch macOS Archives - needs: [release, build-macos-launcher] - runs-on: ubuntu-latest - permissions: - contents: write - strategy: - matrix: - include: - - arch_name: arm64 - - arch_name: x86_64 - steps: - - name: Download launcher artifact - uses: actions/download-artifact@v4 - with: - name: macos-launcher-${{ matrix.arch_name }} - - - name: Patch darwin release archive - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - TAG: ${{ inputs.tag }} - run: | - ARCHIVE_NAME="picoclaw_Darwin_${{ matrix.arch_name }}.tar.gz" - - gh release download "${TAG}" \ - --repo "${{ github.repository }}" \ - --pattern "${ARCHIVE_NAME}" \ - --dir ./patch-tmp - - mkdir -p ./patch-extracted - tar xzf "./patch-tmp/${ARCHIVE_NAME}" -C ./patch-extracted - - cp picoclaw-launcher-cgo ./patch-extracted/picoclaw-launcher - chmod +x ./patch-extracted/picoclaw-launcher - - tar czf "${ARCHIVE_NAME}" -C ./patch-extracted . - - gh release upload "${TAG}" \ - --repo "${{ github.repository }}" \ - "${ARCHIVE_NAME}" --clobber - - echo "Patched ${ARCHIVE_NAME} with CGO launcher (systray enabled)" - upload-tos: name: Upload to TOS - needs: [release, patch-macos-archives] + needs: release if: ${{ inputs.upload_tos }} uses: ./.github/workflows/upload-tos.yml with: diff --git a/.goreleaser.yaml b/.goreleaser.yaml index 3e747bc35..fe43a0921 100644 --- a/.goreleaser.yaml +++ b/.goreleaser.yaml @@ -108,8 +108,8 @@ dockers_v2: ids: - picoclaw images: - - "ghcr.io/{{ .Env.REPO_OWNER }}/picoclaw" - - '{{ with .Env.DOCKERHUB_IMAGE_NAME }}docker.io/{{ . }}{{ end }}' + - "ghcr.io/{{ .Env.GITHUB_REPOSITORY_OWNER }}/picoclaw" + - 'docker.io/{{ .Env.DOCKERHUB_IMAGE_NAME }}' tags: - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly{{ else }}{{ .Tag }}{{ end }}' - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly{{ else }}latest{{ end }}' @@ -124,8 +124,8 @@ dockers_v2: - picoclaw - picoclaw-launcher images: - - "ghcr.io/{{ .Env.REPO_OWNER }}/picoclaw" - - '{{ with .Env.DOCKERHUB_IMAGE_NAME }}docker.io/{{ . }}{{ end }}' + - "ghcr.io/{{ .Env.GITHUB_REPOSITORY_OWNER }}/picoclaw" + - 'docker.io/{{ .Env.DOCKERHUB_IMAGE_NAME }}' tags: - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly-launcher{{ else }}{{ .Tag }}-launcher{{ end }}' - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly-launcher{{ else }}launcher{{ end }}' @@ -178,7 +178,7 @@ nfpms: {{- else if eq .Arch "arm" }}armv{{ .Arm }} {{- else }}{{ .Arch }}{{ end }} vendor: picoclaw - homepage: https://github.com/{{ .Env.REPO_OWNER }}/picoclaw + homepage: https://github.com/{{ .Env.GITHUB_REPOSITORY_OWNER }}/picoclaw maintainer: picoclaw contributors description: picoclaw - a tool for managing and running tasks license: MIT From b792d8b77bd1cc440ec86ac4dbf7b0d166882d0c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 30 Apr 2026 17:19:52 +0000 Subject: [PATCH 40/53] build(deps): bump github.com/aws/aws-sdk-go-v2/config Bumps [github.com/aws/aws-sdk-go-v2/config](https://github.com/aws/aws-sdk-go-v2) from 1.32.16 to 1.32.17. - [Release notes](https://github.com/aws/aws-sdk-go-v2/releases) - [Commits](https://github.com/aws/aws-sdk-go-v2/compare/config/v1.32.16...config/v1.32.17) --- updated-dependencies: - dependency-name: github.com/aws/aws-sdk-go-v2/config dependency-version: 1.32.17 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- go.mod | 28 ++++++++++++++-------------- go.sum | 56 ++++++++++++++++++++++++++++---------------------------- 2 files changed, 42 insertions(+), 42 deletions(-) diff --git a/go.mod b/go.mod index c7e77c0f9..5092c9fab 100644 --- a/go.mod +++ b/go.mod @@ -8,8 +8,8 @@ require ( github.com/adhocore/gronx v1.19.6 github.com/anthropics/anthropic-sdk-go v1.26.0 github.com/atc0005/go-teams-notify/v2 v2.14.0 - github.com/aws/aws-sdk-go-v2 v1.41.6 - github.com/aws/aws-sdk-go-v2/config v1.32.16 + github.com/aws/aws-sdk-go-v2 v1.41.7 + github.com/aws/aws-sdk-go-v2/config v1.32.17 github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.50.5 github.com/bwmarrin/discordgo v0.29.0 github.com/caarlos0/env/v11 v11.4.0 @@ -53,18 +53,18 @@ require ( aead.dev/minisign v0.2.0 // indirect filippo.io/edwards25519 v1.2.0 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.9 // indirect - github.com/aws/aws-sdk-go-v2/credentials v1.19.15 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.22 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.22 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.22 // indirect - github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.23 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.8 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.22 // indirect - github.com/aws/aws-sdk-go-v2/service/signin v1.0.10 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.30.16 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.20 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.42.0 // indirect - github.com/aws/smithy-go v1.25.0 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.19.16 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.23 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.23 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.24 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.9 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23 // indirect + github.com/aws/aws-sdk-go-v2/service/signin v1.0.11 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.30.17 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.42.1 // indirect + github.com/aws/smithy-go v1.25.1 // indirect github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/beeper/argo-go v1.1.2 // indirect github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect diff --git a/go.sum b/go.sum index 5cd39ec8d..2784a7101 100644 --- a/go.sum +++ b/go.sum @@ -21,38 +21,38 @@ github.com/anthropics/anthropic-sdk-go v1.26.0 h1:oUTzFaUpAevfuELAP1sjL6CQJ9HHAf github.com/anthropics/anthropic-sdk-go v1.26.0/go.mod h1:qUKmaW+uuPB64iy1l+4kOSvaLqPXnHTTBKH6RVZ7q5Q= github.com/atc0005/go-teams-notify/v2 v2.14.0 h1:7N+xw+COnYANLREaAveQ65rsNQ12nIZJED9nMLyscCo= github.com/atc0005/go-teams-notify/v2 v2.14.0/go.mod h1:EECsWM2b0Hvoz7O+QdlsvyN2KCUOFQCGj8bUBXv3A3Q= -github.com/aws/aws-sdk-go-v2 v1.41.6 h1:1AX0AthnBQzMx1vbmir3Y4WsnJgiydmnJjiLu+LvXOg= -github.com/aws/aws-sdk-go-v2 v1.41.6/go.mod h1:dy0UzBIfwSeot4grGvY1AqFWN5zgziMmWGzysDnHFcQ= +github.com/aws/aws-sdk-go-v2 v1.41.7 h1:DWpAJt66FmnnaRIOT/8ASTucrvuDPZASqhhLey6tLY8= +github.com/aws/aws-sdk-go-v2 v1.41.7/go.mod h1:4LAfZOPHNVNQEckOACQx60Y8pSRjIkNZQz1w92xpMJc= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.9 h1:adBsCIIpLbLmYnkQU+nAChU5yhVTvu5PerROm+/Kq2A= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.9/go.mod h1:uOYhgfgThm/ZyAuJGNQ5YgNyOlYfqnGpTHXvk3cpykg= -github.com/aws/aws-sdk-go-v2/config v1.32.16 h1:Q0iQ7quUgJP0F/SCRTieScnaMdXr9h/2+wze1u3cNeM= -github.com/aws/aws-sdk-go-v2/config v1.32.16/go.mod h1:duCCnJEFqpt2RC6no1iK6q+8HpwOAkiUua0pY507dQc= -github.com/aws/aws-sdk-go-v2/credentials v1.19.15 h1:fyvgWTszojq8hEnMi8PPBTvZdTtEVmAVyo+NFLHBhH4= -github.com/aws/aws-sdk-go-v2/credentials v1.19.15/go.mod h1:gJiYyMOjNg8OEdRWOf3CrFQxM2a98qmrtjx1zuiQfB8= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.22 h1:IOGsJ1xVWhsi+ZO7/NW8OuZZBtMJLZbk4P5HDjJO0jQ= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.22/go.mod h1:b+hYdbU+jGKfXE8kKM6g1+h+L/Go3vMvzlxBsiuGsxg= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.22 h1:GmLa5Kw1ESqtFpXsx5MmC84QWa/ZrLZvlJGa2y+4kcQ= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.22/go.mod h1:6sW9iWm9DK9YRpRGga/qzrzNLgKpT2cIxb7Vo2eNOp0= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.22 h1:dY4kWZiSaXIzxnKlj17nHnBcXXBfac6UlsAx2qL6XrU= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.22/go.mod h1:KIpEUx0JuRZLO7U6cbV204cWAEco2iC3l061IxlwLtI= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.23 h1:FPXsW9+gMuIeKmz7j6ENWcWtBGTe1kH8r9thNt5Uxx4= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.23/go.mod h1:7J8iGMdRKk6lw2C+cMIphgAnT8uTwBwNOsGkyOCm80U= +github.com/aws/aws-sdk-go-v2/config v1.32.17 h1:FpL4/758/diKwqbytU0prpuiu60fgXKUWCpDJtApclU= +github.com/aws/aws-sdk-go-v2/config v1.32.17/go.mod h1:OXqUMzgXytfoF9JaKkhrOYsyh72t9G+MJH8mMRaexOE= +github.com/aws/aws-sdk-go-v2/credentials v1.19.16 h1:r3RJBuU7X9ibt8RHbMjWE6y60QbKBiII6wSrXnapxSU= +github.com/aws/aws-sdk-go-v2/credentials v1.19.16/go.mod h1:6cx7zqDENJDbBIIWX6P8s0h6hqHC8Avbjh9Dseo27ug= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.23 h1:UuSfcORqNSz/ey3VPRS8TcVH2Ikf0/sC+Hdj400QI6U= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.23/go.mod h1:+G/OSGiOFnSOkYloKj/9M35s74LgVAdJBSD5lsFfqKg= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23 h1:GpT/TrnBYuE5gan2cZbTtvP+JlHsutdmlV2YfEyNde0= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.23/go.mod h1:xYWD6BS9ywC5bS3sz9Xh04whO/hzK2plt2Zkyrp4JuA= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.23 h1:bpd8vxhlQi2r1hiueOw02f/duEPTMK59Q4QMAoTTtTo= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.23/go.mod h1:15DfR2nw+CRHIk0tqNyifu3G1YdAOy68RftkhMDDwYk= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.24 h1:OQqn11BtaYv1WLUowvcA30MpzIu8Ti4pcLPIIyoKZrA= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.24/go.mod h1:X5ZJyfwVrWA96GzPmUCWFQaEARPR7gCrpq2E92PJwAE= github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.50.5 h1:ZGTl4Rxft1uyENAlGESY04hMzE4cLLNUPI7dGw08haw= github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.50.5/go.mod h1:jnugA+VgESQGgXuEKK6zVToET/DtODq7LQYpe+BkKT4= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.8 h1:HtOTYcbVcGABLOVuPYaIihj6IlkqubBwFj10K5fxRek= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.8/go.mod h1:VsK9abqQeGlzPgUr+isNWzPlK2vKe9INMLWnY65f5Xs= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.22 h1:PUmZeJU6Y1Lbvt9WFuJ0ugUK2xn6hIWUBBbKuOWF30s= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.22/go.mod h1:nO6egFBoAaoXze24a2C0NjQCvdpk8OueRoYimvEB9jo= -github.com/aws/aws-sdk-go-v2/service/signin v1.0.10 h1:a1Fq/KXn75wSzoJaPQTgZO0wHGqE9mjFnylnqEPTchA= -github.com/aws/aws-sdk-go-v2/service/signin v1.0.10/go.mod h1:p6+MXNxW7IA6dMgHfTAzljuwSKD0NCm/4lbS4t6+7vI= -github.com/aws/aws-sdk-go-v2/service/sso v1.30.16 h1:x6bKbmDhsgSZwv6q19wY/u3rLk/3FGjJWyqKcIRufpE= -github.com/aws/aws-sdk-go-v2/service/sso v1.30.16/go.mod h1:CudnEVKRtLn0+3uMV0yEXZ+YZOKnAtUJ5DmDhilVnIw= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.20 h1:oK/njaL8GtyEihkWMD4k3VgHCT64RQKkZwh0DG5j8ak= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.20/go.mod h1:JHs8/y1f3zY7U5WcuzoJ/yAYGYtNIVPKLIbp61euvmg= -github.com/aws/aws-sdk-go-v2/service/sts v1.42.0 h1:ks8KBcZPh3PYISr5dAiXCM5/Thcuxk8l+PG4+A0exds= -github.com/aws/aws-sdk-go-v2/service/sts v1.42.0/go.mod h1:pFw33T0WLvXU3rw1WBkpMlkgIn54eCB5FYLhjDc9Foo= -github.com/aws/smithy-go v1.25.0 h1:Sz/XJ64rwuiKtB6j98nDIPyYrV1nVNJ4YU74gttcl5U= -github.com/aws/smithy-go v1.25.0/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.9 h1:FLudkZLt5ci0ozzgkVo8BJGwvqNaZbTWb3UcucAateA= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.9/go.mod h1:w7wZ/s9qK7c8g4al+UyoF1Sp/Z45UwMGcqIzLWVQHWk= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23 h1:pbrxO/kuIwgEsOPLkaHu0O+m4fNgLU8B3vxQ+72jTPw= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.23/go.mod h1:/CMNUqoj46HpS3MNRDEDIwcgEnrtZlKRaHNaHxIFpNA= +github.com/aws/aws-sdk-go-v2/service/signin v1.0.11 h1:TdJ+HdzOBhU8+iVAOGUTU63VXopcumCOF1paFulHWZc= +github.com/aws/aws-sdk-go-v2/service/signin v1.0.11/go.mod h1:R82ZRExE/nheo0N+T8zHPcLRTcH8MGsnR3BiVGX0TwI= +github.com/aws/aws-sdk-go-v2/service/sso v1.30.17 h1:7byT8HUWrgoRp6sXjxtZwgOKfhss5fW6SkLBtqzgRoE= +github.com/aws/aws-sdk-go-v2/service/sso v1.30.17/go.mod h1:xNWknVi4Ezm1vg1QsB/5EWpAJURq22uqd38U8qKvOJc= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21 h1:+1Kl1zx6bWi4X7cKi3VYh29h8BvsCoHQEQ6ST9X8w7w= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.21/go.mod h1:4vIRDq+CJB2xFAXZ+YgGUTiEft7oAQlhIs71xcSeuVg= +github.com/aws/aws-sdk-go-v2/service/sts v1.42.1 h1:F/M5Y9I3nwr2IEpshZgh1GeHpOItExNM9L1euNuh/fk= +github.com/aws/aws-sdk-go-v2/service/sts v1.42.1/go.mod h1:mTNxImtovCOEEuD65mKW7DCsL+2gjEH+RPEAexAzAio= +github.com/aws/smithy-go v1.25.1 h1:J8ERsGSU7d+aCmdQur5Txg6bVoYelvQJgtZehD12GkI= +github.com/aws/smithy-go v1.25.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= github.com/beeper/argo-go v1.1.2 h1:UQI2G8F+NLfGTOmTUI0254pGKx/HUU/etbUGTJv91Fs= From a94ba8218186b7d0e1202d2bf137c0059399fa34 Mon Sep 17 00:00:00 2001 From: BeaconCat <111232138+BeaconCat@users.noreply.github.com> Date: Sat, 2 May 2026 16:55:53 +0800 Subject: [PATCH 41/53] chore: update WeChat group QR code (#2747) Co-authored-by: BeaconCat --- assets/wechat.png | Bin 369090 -> 367661 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/assets/wechat.png b/assets/wechat.png index b368f75d3a837d2fee35d01eac6384f2797723df..18247ff82845559ea618bb048bf55d4f7ab1aa9a 100644 GIT binary patch literal 367661 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

B$+j& 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 wjNZL5dfmwAbt9wKjbOcQWEd9?TP^C$ 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

8kF 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

~3&>~>-7gE4svWECD4%v%AUk+hx)uFvV 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

l5u~HeZ$E(uPoaFJvIeSGAf|a9 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