From c47f5fd2c43f7d797f4004019e65fea720d75681 Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 21:27:13 +0800 Subject: [PATCH 01/87] feat(agent): add TargetAgentID to SubTurnConfig for cross-agent delegation When TargetAgentID is set, spawnSubTurn resolves the target AgentInstance from the registry and uses it as the base for the child turn. This gives the child turn the target's workspace, model, tools, and system prompt instead of inheriting from the caller. Model validation is relaxed: empty Model is accepted when TargetAgentID provides the model implicitly via the resolved agent instance. Ref: #2148 --- pkg/agent/subturn.go | 33 ++++++++++++++++++++++++--------- pkg/tools/subagent.go | 1 + 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/pkg/agent/subturn.go b/pkg/agent/subturn.go index 9ee7b15c9..61d25d248 100644 --- a/pkg/agent/subturn.go +++ b/pkg/agent/subturn.go @@ -172,7 +172,10 @@ type SubTurnConfig struct { // Used by team tool to enforce token limits across all team members. InitialTokenBudget *atomic.Int64 - // Can be extended with temperature, topP, etc. + // TargetAgentID, when set, runs the sub-turn as the specified agent. + // The target agent's workspace, model, tools, and system prompt are used + // instead of the caller's. If empty, the sub-turn runs as the parent agent. + TargetAgentID string } // ====================== Context Keys ====================== @@ -230,6 +233,7 @@ func (s *AgentLoopSpawner) SpawnSubTurn( Critical: cfg.Critical, Timeout: cfg.Timeout, MaxContextRunes: cfg.MaxContextRunes, + TargetAgentID: cfg.TargetAgentID, } return spawnSubTurn(ctx, s.al, parentTS, agentCfg) @@ -312,8 +316,9 @@ func spawnSubTurn( return nil, ErrDepthLimitExceeded } - // 2. Config validation - if cfg.Model == "" { + // 2. Config validation: Model is required unless TargetAgentID is set + // (the target agent provides its own model). + if cfg.Model == "" && cfg.TargetAgentID == "" { return nil, ErrInvalidSubTurnConfig } @@ -331,12 +336,22 @@ func spawnSubTurn( childID := al.generateSubTurnID() - // Get the agent instance from parent, falling back to the default agent. - // Wrap it in a shallow copy that uses an ephemeral (in-memory only) session store - // so that child turns never pollute or persist to the parent's session history. - baseAgent := parentTS.agent - if baseAgent == nil { - baseAgent = al.registry.GetDefaultAgent() + // Resolve the agent instance for the child turn. + // When TargetAgentID is set, look up that agent from the registry so the + // child runs with the target's workspace, model, tools, and system prompt. + // Otherwise fall back to the parent's agent (existing behavior). + var baseAgent *AgentInstance + if cfg.TargetAgentID != "" { + var ok bool + baseAgent, ok = al.registry.GetAgent(cfg.TargetAgentID) + if !ok { + return nil, fmt.Errorf("target agent %q not found in registry", cfg.TargetAgentID) + } + } else { + baseAgent = parentTS.agent + if baseAgent == nil { + baseAgent = al.registry.GetDefaultAgent() + } } if baseAgent == nil { return nil, errors.New("parent turnState has no agent instance") diff --git a/pkg/tools/subagent.go b/pkg/tools/subagent.go index ada89efb7..feeabe536 100644 --- a/pkg/tools/subagent.go +++ b/pkg/tools/subagent.go @@ -30,6 +30,7 @@ type SubTurnConfig struct { ActualSystemPrompt string InitialMessages []providers.Message InitialTokenBudget *atomic.Int64 // Shared token budget for team members; nil if no budget + TargetAgentID string // If set, run as this agent (its workspace, model, tools) } type SubagentTask struct { From c8335bfd47c83401c674b7fa7f772d7a4a17aabe Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 21:27:39 +0800 Subject: [PATCH 02/87] test(agent): verify TargetAgentID resolves to correct agent instance Add multi-agent test setup (newMultiAgentLoop) with two agents using distinct models (model-alpha, model-beta). Three new tests: - UsesTargetAgent: parent=alpha delegates to beta, event log confirms child runs as agent_id=beta with model=model-beta - NotFound: TargetAgentID pointing to nonexistent agent returns error - EmptyModelAccepted: empty Model field accepted when TargetAgentID provides the model implicitly Ref: #2148 --- pkg/agent/subturn_test.go | 150 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 150 insertions(+) diff --git a/pkg/agent/subturn_test.go b/pkg/agent/subturn_test.go index 6a2ba835d..b3015149e 100644 --- a/pkg/agent/subturn_test.go +++ b/pkg/agent/subturn_test.go @@ -4,6 +4,9 @@ import ( "context" "errors" "fmt" + "os" + "path/filepath" + "strings" "sync" "testing" "time" @@ -2065,3 +2068,150 @@ func TestSubTurn_IndependentContext(t *testing.T) { t.Log("✓ SubTurn completed successfully (independent context)") } } + +// ====================== TargetAgentID Tests ====================== + +// newMultiAgentLoop creates an AgentLoop with two named agents for testing +// cross-agent delegation via TargetAgentID. +func newMultiAgentLoop(t *testing.T) (*AgentLoop, func()) { + t.Helper() + tmpDir, err := os.MkdirTemp("", "multiagent-test-*") + if err != nil { + t.Fatalf("create temp dir: %v", err) + } + + alphaDir := filepath.Join(tmpDir, "alpha") + betaDir := filepath.Join(tmpDir, "beta") + os.MkdirAll(alphaDir, 0o755) + os.MkdirAll(betaDir, 0o755) + + cfg := &config.Config{ + Agents: config.AgentsConfig{ + Defaults: config.AgentDefaults{ + Workspace: tmpDir, + ModelName: "default-model", + MaxTokens: 4096, + MaxToolIterations: 10, + }, + List: []config.AgentConfig{ + { + ID: "alpha", + Workspace: alphaDir, + Model: &config.AgentModelConfig{Primary: "model-alpha"}, + }, + { + ID: "beta", + Workspace: betaDir, + Model: &config.AgentModelConfig{Primary: "model-beta"}, + }, + }, + }, + } + + msgBus := bus.NewMessageBus() + provider := &mockProvider{} + al := NewAgentLoop(cfg, msgBus, provider) + + return al, func() { os.RemoveAll(tmpDir) } +} + +func TestSpawnSubTurn_TargetAgentID_UsesTargetAgent(t *testing.T) { + al, cleanup := newMultiAgentLoop(t) + defer cleanup() + + alphaAgent, ok := al.registry.GetAgent("alpha") + if !ok { + t.Fatal("alpha agent not in registry") + } + betaAgent, ok := al.registry.GetAgent("beta") + if !ok { + t.Fatal("beta agent not in registry") + } + + // Parent is alpha, target is beta + parent := &turnState{ + ctx: context.Background(), + turnID: "parent-alpha", + depth: 0, + childTurnIDs: []string{}, + pendingResults: make(chan *tools.ToolResult, 4), + concurrencySem: make(chan struct{}, testMaxConcurrentSubTurns), + session: &ephemeralSessionStore{}, + agent: alphaAgent, + } + + result, err := spawnSubTurn(context.Background(), al, parent, SubTurnConfig{ + TargetAgentID: "beta", + SystemPrompt: "task for beta", + }) + if err != nil { + t.Fatalf("spawnSubTurn failed: %v", err) + } + if result == nil { + t.Fatal("expected non-nil result") + } + + // Verify the two agents have distinct models (test setup sanity check) + if alphaAgent.Model == betaAgent.Model { + t.Fatal("test setup error: alpha and beta should have different models") + } +} + +func TestSpawnSubTurn_TargetAgentID_NotFound(t *testing.T) { + al, cleanup := newMultiAgentLoop(t) + defer cleanup() + + alphaAgent, _ := al.registry.GetAgent("alpha") + parent := &turnState{ + ctx: context.Background(), + turnID: "parent-alpha", + depth: 0, + childTurnIDs: []string{}, + pendingResults: make(chan *tools.ToolResult, 4), + concurrencySem: make(chan struct{}, testMaxConcurrentSubTurns), + session: &ephemeralSessionStore{}, + agent: alphaAgent, + } + + _, err := spawnSubTurn(context.Background(), al, parent, SubTurnConfig{ + TargetAgentID: "nonexistent", + SystemPrompt: "task", + }) + + if err == nil { + t.Fatal("expected error for nonexistent agent") + } + if !strings.Contains(err.Error(), "not found") { + t.Errorf("error should mention 'not found', got: %v", err) + } +} + +func TestSpawnSubTurn_TargetAgentID_EmptyModelAccepted(t *testing.T) { + al, cleanup := newMultiAgentLoop(t) + defer cleanup() + + alphaAgent, _ := al.registry.GetAgent("alpha") + parent := &turnState{ + ctx: context.Background(), + turnID: "parent-alpha", + depth: 0, + childTurnIDs: []string{}, + pendingResults: make(chan *tools.ToolResult, 4), + concurrencySem: make(chan struct{}, testMaxConcurrentSubTurns), + session: &ephemeralSessionStore{}, + agent: alphaAgent, + } + + // Model is empty but TargetAgentID is set — should NOT fail validation + result, err := spawnSubTurn(context.Background(), al, parent, SubTurnConfig{ + Model: "", // intentionally empty + TargetAgentID: "beta", + SystemPrompt: "task for beta", + }) + if err != nil { + t.Fatalf("should accept empty Model when TargetAgentID is set, got: %v", err) + } + if result == nil { + t.Fatal("expected non-nil result") + } +} From 484ef399f1bcb77cb80cfb77feee784a4afa1b66 Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 21:28:31 +0800 Subject: [PATCH 03/87] feat(tools): add delegate tool for synchronous cross-agent task handoff delegate(agent_id, task) hands off a task to a named agent and blocks until the result is ready. The target agent runs with its own config via the TargetAgentID mechanism in SubTurnConfig. Key behaviors: - Self-delegation explicitly rejected - Permission gated by subagents.allow_agents (D4) - Spawner errors preserve the underlying error via WithError - Nil result from spawner handled gracefully - Response attributed with target agent ID Ref: #2148 --- pkg/tools/delegate.go | 101 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 pkg/tools/delegate.go diff --git a/pkg/tools/delegate.go b/pkg/tools/delegate.go new file mode 100644 index 000000000..8831ffeb3 --- /dev/null +++ b/pkg/tools/delegate.go @@ -0,0 +1,101 @@ +package tools + +import ( + "context" + "fmt" + "strings" +) + +// DelegateTool delegates a task to a specific named agent and waits for +// the result. Unlike spawn (async, fire-and-forget) or subagent (sync but +// generic), delegate targets a named agent and runs the task using that +// agent's own workspace, model, and tools. +type DelegateTool struct { + spawner SubTurnSpawner + allowlistCheck func(targetAgentID string) bool + selfAgentID string +} + +func NewDelegateTool() *DelegateTool { + return &DelegateTool{} +} + +func (t *DelegateTool) SetSpawner(spawner SubTurnSpawner) { + t.spawner = spawner +} + +func (t *DelegateTool) SetAllowlistChecker(check func(targetAgentID string) bool) { + t.allowlistCheck = check +} + +func (t *DelegateTool) SetSelfAgentID(id string) { + t.selfAgentID = id +} + +func (t *DelegateTool) Name() string { + return "delegate" +} + +func (t *DelegateTool) Description() string { + return "Delegate a task to another agent and wait for the result. " + + "Use this when another agent is better suited to handle a specific task " + + "based on their capabilities. The target agent runs with its own workspace, " + + "model, and tools." +} + +func (t *DelegateTool) Parameters() map[string]any { + return map[string]any{ + "type": "object", + "properties": map[string]any{ + "agent_id": map[string]any{ + "type": "string", + "description": "The ID of the target agent to delegate the task to", + }, + "task": map[string]any{ + "type": "string", + "description": "Clear description of the task to delegate", + }, + }, + "required": []string{"agent_id", "task"}, + } +} + +func (t *DelegateTool) Execute(ctx context.Context, args map[string]any) *ToolResult { + agentID, _ := args["agent_id"].(string) + if strings.TrimSpace(agentID) == "" { + return ErrorResult("agent_id is required and must be a non-empty string") + } + + task, _ := args["task"].(string) + if strings.TrimSpace(task) == "" { + return ErrorResult("task is required and must be a non-empty string") + } + + if t.selfAgentID != "" && agentID == t.selfAgentID { + return ErrorResult("cannot delegate to self") + } + + if t.allowlistCheck != nil && !t.allowlistCheck(agentID) { + return ErrorResult(fmt.Sprintf("not allowed to delegate to agent %q", agentID)) + } + + if t.spawner == nil { + return ErrorResult("delegate tool not configured") + } + + result, err := t.spawner.SpawnSubTurn(ctx, SubTurnConfig{ + TargetAgentID: agentID, + SystemPrompt: task, + Async: false, + }) + if err != nil { + return ErrorResult(fmt.Sprintf("delegation to agent %q failed: %v", agentID, err)).WithError(err) + } + if result == nil { + return ErrorResult(fmt.Sprintf("delegation to agent %q returned no result", agentID)) + } + + result.ForLLM = fmt.Sprintf("[Response from agent %q]\n%s", agentID, result.ForLLM) + + return result +} From 0ff78fa53f453a31a665a079076db7da8b5d72e5 Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 21:28:54 +0800 Subject: [PATCH 04/87] test(tools): add delegate tool unit tests 12 test cases covering: - success path with result attribution - agent_id validation (missing, empty, whitespace, wrong type) - task validation (missing, empty, whitespace) - permission denied / allowed via allowlist checker - self-delegation blocked - nil spawner, spawner error, nil result from spawner - open access when no allowlist checker is set Ref: #2148 --- pkg/tools/delegate_test.go | 280 +++++++++++++++++++++++++++++++++++++ 1 file changed, 280 insertions(+) create mode 100644 pkg/tools/delegate_test.go diff --git a/pkg/tools/delegate_test.go b/pkg/tools/delegate_test.go new file mode 100644 index 000000000..f1b4c456f --- /dev/null +++ b/pkg/tools/delegate_test.go @@ -0,0 +1,280 @@ +package tools + +import ( + "context" + "fmt" + "strings" + "testing" +) + +// delegateMockSpawner records the config and returns a canned result. +type delegateMockSpawner struct { + lastCfg SubTurnConfig + result *ToolResult + err error +} + +func (m *delegateMockSpawner) SpawnSubTurn(_ context.Context, cfg SubTurnConfig) (*ToolResult, error) { + m.lastCfg = cfg + if m.err != nil { + return nil, m.err + } + if m.result != nil { + return m.result, nil + } + return &ToolResult{ + ForLLM: "completed: " + cfg.SystemPrompt, + ForUser: "completed", + }, nil +} + +func TestDelegateTool_Name(t *testing.T) { + tool := NewDelegateTool() + if tool.Name() != "delegate" { + t.Errorf("Name() = %q, want %q", tool.Name(), "delegate") + } +} + +func TestDelegateTool_Parameters(t *testing.T) { + tool := NewDelegateTool() + params := tool.Parameters() + + props, ok := params["properties"].(map[string]any) + if !ok { + t.Fatal("properties should be a map") + } + _, hasAgentID := props["agent_id"] + if !hasAgentID { + t.Error("agent_id parameter should exist") + } + _, hasTask := props["task"] + if !hasTask { + t.Error("task parameter should exist") + } + + required, ok := params["required"].([]string) + if !ok { + t.Fatal("required should be a string array") + } + if len(required) != 2 { + t.Fatalf("required should have 2 entries, got %d", len(required)) + } +} + +func TestDelegateTool_Execute_Success(t *testing.T) { + spawner := &delegateMockSpawner{} + tool := NewDelegateTool() + tool.SetSpawner(spawner) + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "researcher", + "task": "summarize the logs", + }) + + if result.IsError { + t.Fatalf("expected success, got error: %s", result.ForLLM) + } + if !strings.Contains(result.ForLLM, `[Response from agent "researcher"]`) { + t.Errorf("result should contain attribution, got: %s", result.ForLLM) + } + if !strings.Contains(result.ForLLM, "summarize the logs") { + t.Errorf("result should contain task output, got: %s", result.ForLLM) + } + + // Verify spawner received correct config + if spawner.lastCfg.TargetAgentID != "researcher" { + t.Errorf("TargetAgentID = %q, want %q", spawner.lastCfg.TargetAgentID, "researcher") + } + if spawner.lastCfg.Async { + t.Error("delegate should be synchronous (Async=false)") + } + if spawner.lastCfg.SystemPrompt != "summarize the logs" { + t.Errorf("SystemPrompt = %q, want %q", spawner.lastCfg.SystemPrompt, "summarize the logs") + } +} + +func TestDelegateTool_Execute_EmptyAgentID(t *testing.T) { + tests := []struct { + name string + args map[string]any + }{ + {"missing", map[string]any{"task": "test"}}, + {"empty string", map[string]any{"agent_id": "", "task": "test"}}, + {"whitespace only", map[string]any{"agent_id": " ", "task": "test"}}, + {"wrong type", map[string]any{"agent_id": 123, "task": "test"}}, + } + + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tool.Execute(context.Background(), tt.args) + if !result.IsError { + t.Error("expected error for invalid agent_id") + } + if !strings.Contains(result.ForLLM, "agent_id is required") { + t.Errorf("error should mention agent_id, got: %s", result.ForLLM) + } + }) + } +} + +func TestDelegateTool_Execute_EmptyTask(t *testing.T) { + tests := []struct { + name string + args map[string]any + }{ + {"missing", map[string]any{"agent_id": "a"}}, + {"empty string", map[string]any{"agent_id": "a", "task": ""}}, + {"whitespace only", map[string]any{"agent_id": "a", "task": "\t\n"}}, + } + + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := tool.Execute(context.Background(), tt.args) + if !result.IsError { + t.Error("expected error for invalid task") + } + if !strings.Contains(result.ForLLM, "task is required") { + t.Errorf("error should mention task, got: %s", result.ForLLM) + } + }) + } +} + +func TestDelegateTool_Execute_PermissionDenied(t *testing.T) { + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + tool.SetAllowlistChecker(func(targetAgentID string) bool { + return targetAgentID == "allowed-agent" + }) + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "forbidden-agent", + "task": "test", + }) + + if !result.IsError { + t.Error("expected error for denied agent") + } + if !strings.Contains(result.ForLLM, "not allowed to delegate") { + t.Errorf("error should mention permission, got: %s", result.ForLLM) + } +} + +func TestDelegateTool_Execute_PermissionAllowed(t *testing.T) { + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + tool.SetAllowlistChecker(func(targetAgentID string) bool { + return targetAgentID == "allowed-agent" + }) + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "allowed-agent", + "task": "test", + }) + + if result.IsError { + t.Errorf("expected success for allowed agent, got error: %s", result.ForLLM) + } +} + +func TestDelegateTool_Execute_NoSpawner(t *testing.T) { + tool := NewDelegateTool() + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "a", + "task": "test", + }) + + if !result.IsError { + t.Error("expected error when spawner is nil") + } + if !strings.Contains(result.ForLLM, "not configured") { + t.Errorf("error should mention not configured, got: %s", result.ForLLM) + } +} + +func TestDelegateTool_Execute_SpawnerError(t *testing.T) { + spawner := &delegateMockSpawner{ + err: fmt.Errorf("context deadline exceeded"), + } + tool := NewDelegateTool() + tool.SetSpawner(spawner) + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "researcher", + "task": "test", + }) + + if !result.IsError { + t.Error("expected error when spawner fails") + } + if !strings.Contains(result.ForLLM, "delegation to agent") { + t.Errorf("error should mention delegation failure, got: %s", result.ForLLM) + } + if !strings.Contains(result.ForLLM, "context deadline exceeded") { + t.Errorf("error should propagate cause, got: %s", result.ForLLM) + } +} + +func TestDelegateTool_Execute_NoAllowlistCheck(t *testing.T) { + // When no allowlist checker is set, all agents are allowed + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "any-agent", + "task": "test", + }) + + if result.IsError { + t.Errorf("expected success without allowlist, got error: %s", result.ForLLM) + } +} + +func TestDelegateTool_Execute_NilResult(t *testing.T) { + tool := NewDelegateTool() + tool.SetSpawner(&nilResultSpawner{}) + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "researcher", + "task": "test", + }) + + if !result.IsError { + t.Error("expected error for nil result") + } + if !strings.Contains(result.ForLLM, "returned no result") { + t.Errorf("error should mention no result, got: %s", result.ForLLM) + } +} + +func TestDelegateTool_Execute_SelfDelegation(t *testing.T) { + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + tool.SetSelfAgentID("alpha") + + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": "alpha", + "task": "test", + }) + + if !result.IsError { + t.Error("expected error for self-delegation") + } + if !strings.Contains(result.ForLLM, "cannot delegate to self") { + t.Errorf("error should mention self-delegation, got: %s", result.ForLLM) + } +} + +// nilResultSpawner always returns (nil, nil). +type nilResultSpawner struct{} + +func (m *nilResultSpawner) SpawnSubTurn(_ context.Context, _ SubTurnConfig) (*ToolResult, error) { + return nil, nil +} From 039f35563e6222da0acac3a1dada2f27e6174bec Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 21:29:29 +0800 Subject: [PATCH 05/87] feat(agent): wire delegate tool registration for multi-agent setups MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Register the delegate tool in registerSharedTools when multiple agents are configured. Gated independently from the subagent tool — delegate uses SubTurn directly and does not depend on SubagentManager. Self-delegation is prevented by injecting the current agent ID. Permission is enforced via CanSpawnSubagent (reuses allow_agents config). Single-agent setups are unaffected: the tool is not registered when only one agent exists in the registry. Ref: #2148 --- pkg/agent/loop.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index a856c0fca..d31d2af45 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -440,6 +440,20 @@ func registerSharedTools( } else if (spawnEnabled || spawnStatusEnabled) && !cfg.Tools.IsToolEnabled("subagent") { logger.WarnCF("agent", "spawn/spawn_status tools require subagent to be enabled", nil) } + + // Register delegate tool for multi-agent setups. + // Delegation uses the SubTurn mechanism directly (not SubagentManager), + // so it does not depend on the subagent tool being enabled. + if cfg.Tools.IsToolEnabled("delegate") && len(registry.ListAgentIDs()) > 1 { + delegateTool := tools.NewDelegateTool() + delegateTool.SetSpawner(NewSubTurnSpawner(al)) + currentAgentID := agentID + delegateTool.SetSelfAgentID(currentAgentID) + delegateTool.SetAllowlistChecker(func(targetAgentID string) bool { + return registry.CanSpawnSubagent(currentAgentID, targetAgentID) + }) + agent.Tools.Register(delegateTool) + } } } From df486b99393cf9e69550b2f4406938977a5f7b2b Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 22:23:17 +0800 Subject: [PATCH 06/87] fix(tools): normalize agent_id before self-check and delegation Apply routing.NormalizeAgentID to the raw agent_id input before any logic runs. This prevents case/whitespace variants like "ALPHA" or " alpha " from bypassing the self-delegation guard while still resolving to the same agent in the registry. The normalized value is used consistently for self-check, allowlist, SpawnSubTurn, and result attribution. Ref: #2148 --- pkg/tools/delegate.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pkg/tools/delegate.go b/pkg/tools/delegate.go index 8831ffeb3..dcde27718 100644 --- a/pkg/tools/delegate.go +++ b/pkg/tools/delegate.go @@ -4,6 +4,8 @@ import ( "context" "fmt" "strings" + + "github.com/sipeed/picoclaw/pkg/routing" ) // DelegateTool delegates a task to a specific named agent and waits for @@ -61,10 +63,11 @@ func (t *DelegateTool) Parameters() map[string]any { } func (t *DelegateTool) Execute(ctx context.Context, args map[string]any) *ToolResult { - agentID, _ := args["agent_id"].(string) - if strings.TrimSpace(agentID) == "" { + rawAgentID, _ := args["agent_id"].(string) + if strings.TrimSpace(rawAgentID) == "" { return ErrorResult("agent_id is required and must be a non-empty string") } + agentID := routing.NormalizeAgentID(rawAgentID) task, _ := args["task"].(string) if strings.TrimSpace(task) == "" { From 6db17b8211a99c070294437e8fca03a4ddcd0269 Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 22:23:47 +0800 Subject: [PATCH 07/87] test(tools): verify normalization prevents self-delegation bypass Add table-driven test with case and whitespace variants (ALPHA, " Alpha ", " alpha ") that should all be caught by the self-check after normalization. Ref: #2148 --- pkg/tools/delegate_test.go | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/pkg/tools/delegate_test.go b/pkg/tools/delegate_test.go index f1b4c456f..729c524a7 100644 --- a/pkg/tools/delegate_test.go +++ b/pkg/tools/delegate_test.go @@ -272,6 +272,26 @@ func TestDelegateTool_Execute_SelfDelegation(t *testing.T) { } } +func TestDelegateTool_Execute_SelfDelegation_Normalized(t *testing.T) { + tool := NewDelegateTool() + tool.SetSpawner(&delegateMockSpawner{}) + tool.SetSelfAgentID("alpha") // stored normalized + + // Case-insensitive and whitespace variants should still be caught + variants := []string{"ALPHA", " Alpha ", " alpha "} + for _, v := range variants { + t.Run(v, func(t *testing.T) { + result := tool.Execute(context.Background(), map[string]any{ + "agent_id": v, + "task": "test", + }) + if !result.IsError { + t.Errorf("agent_id=%q should be caught as self-delegation", v) + } + }) + } +} + // nilResultSpawner always returns (nil, nil). type nilResultSpawner struct{} From 6ee66123f22f96eb273fb4b247855bbe1d7ade89 Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 22:24:47 +0800 Subject: [PATCH 08/87] refactor(agent): simplify delegate registration gate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remove the IsToolEnabled("delegate") check — there is no "delegate" entry in ToolsConfig, so the check was always true. The only real gate is len(agents) > 1, which is the intended behavior: delegate is auto-registered in multi-agent setups. Ref: #2148 --- pkg/agent/loop.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/pkg/agent/loop.go b/pkg/agent/loop.go index d31d2af45..c48c1041b 100644 --- a/pkg/agent/loop.go +++ b/pkg/agent/loop.go @@ -442,9 +442,10 @@ func registerSharedTools( } // Register delegate tool for multi-agent setups. - // Delegation uses the SubTurn mechanism directly (not SubagentManager), - // so it does not depend on the subagent tool being enabled. - if cfg.Tools.IsToolEnabled("delegate") && len(registry.ListAgentIDs()) > 1 { + // Auto-enabled when multiple agents exist. Delegation uses the SubTurn + // mechanism directly (not SubagentManager) and is independent of the + // subagent tool. + if len(registry.ListAgentIDs()) > 1 { delegateTool := tools.NewDelegateTool() delegateTool.SetSpawner(NewSubTurnSpawner(al)) currentAgentID := agentID From a34120b8219eb342846c538b5ddb4c0e59a095c7 Mon Sep 17 00:00:00 2001 From: xiaoen <2768753269@qq.com> Date: Wed, 15 Apr 2026 22:27:05 +0800 Subject: [PATCH 09/87] test(agent): assert child turn uses target agent model MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace generic mockProvider with modelRecordingProvider that captures the model parameter passed to Chat(). After delegation from alpha to beta, assert the recorded model is "model-beta" — proving the child turn actually ran with the target agent's configuration, not the caller's. Also add wiring tests: - TestDelegateToolNotRegistered_SingleAgent: single-agent has no delegate in its tool registry - TestDelegateToolRegistered_MultiAgent: both agents in a two-agent setup have the delegate tool Ref: #2148 --- pkg/agent/subturn_test.go | 80 +++++++++++++++++++++++++++++++++------ 1 file changed, 68 insertions(+), 12 deletions(-) diff --git a/pkg/agent/subturn_test.go b/pkg/agent/subturn_test.go index b3015149e..c28d8c045 100644 --- a/pkg/agent/subturn_test.go +++ b/pkg/agent/subturn_test.go @@ -2071,9 +2071,36 @@ func TestSubTurn_IndependentContext(t *testing.T) { // ====================== TargetAgentID Tests ====================== +// modelRecordingProvider captures the model passed to Chat for test assertions. +type modelRecordingProvider struct { + mu sync.Mutex + lastModel string +} + +func (rp *modelRecordingProvider) Chat( + _ context.Context, + _ []providers.Message, + _ []providers.ToolDefinition, + model string, + _ map[string]any, +) (*providers.LLMResponse, error) { + rp.mu.Lock() + rp.lastModel = model + rp.mu.Unlock() + return &providers.LLMResponse{Content: "Mock response"}, nil +} + +func (rp *modelRecordingProvider) GetDefaultModel() string { return "mock-model" } + +func (rp *modelRecordingProvider) getLastModel() string { + rp.mu.Lock() + defer rp.mu.Unlock() + return rp.lastModel +} + // newMultiAgentLoop creates an AgentLoop with two named agents for testing // cross-agent delegation via TargetAgentID. -func newMultiAgentLoop(t *testing.T) (*AgentLoop, func()) { +func newMultiAgentLoop(t *testing.T, provider providers.LLMProvider) (*AgentLoop, func()) { t.Helper() tmpDir, err := os.MkdirTemp("", "multiagent-test-*") if err != nil { @@ -2109,24 +2136,20 @@ func newMultiAgentLoop(t *testing.T) (*AgentLoop, func()) { } msgBus := bus.NewMessageBus() - provider := &mockProvider{} al := NewAgentLoop(cfg, msgBus, provider) return al, func() { os.RemoveAll(tmpDir) } } func TestSpawnSubTurn_TargetAgentID_UsesTargetAgent(t *testing.T) { - al, cleanup := newMultiAgentLoop(t) + rp := &modelRecordingProvider{} + al, cleanup := newMultiAgentLoop(t, rp) defer cleanup() alphaAgent, ok := al.registry.GetAgent("alpha") if !ok { t.Fatal("alpha agent not in registry") } - betaAgent, ok := al.registry.GetAgent("beta") - if !ok { - t.Fatal("beta agent not in registry") - } // Parent is alpha, target is beta parent := &turnState{ @@ -2151,14 +2174,16 @@ func TestSpawnSubTurn_TargetAgentID_UsesTargetAgent(t *testing.T) { t.Fatal("expected non-nil result") } - // Verify the two agents have distinct models (test setup sanity check) - if alphaAgent.Model == betaAgent.Model { - t.Fatal("test setup error: alpha and beta should have different models") + // The recording provider captures the model passed to Chat(). + // If TargetAgentID works correctly, the child turn should have + // used beta's model, not alpha's. + if got := rp.getLastModel(); got != "model-beta" { + t.Errorf("child turn used model %q, want %q", got, "model-beta") } } func TestSpawnSubTurn_TargetAgentID_NotFound(t *testing.T) { - al, cleanup := newMultiAgentLoop(t) + al, cleanup := newMultiAgentLoop(t, &mockProvider{}) defer cleanup() alphaAgent, _ := al.registry.GetAgent("alpha") @@ -2187,7 +2212,7 @@ func TestSpawnSubTurn_TargetAgentID_NotFound(t *testing.T) { } func TestSpawnSubTurn_TargetAgentID_EmptyModelAccepted(t *testing.T) { - al, cleanup := newMultiAgentLoop(t) + al, cleanup := newMultiAgentLoop(t, &mockProvider{}) defer cleanup() alphaAgent, _ := al.registry.GetAgent("alpha") @@ -2215,3 +2240,34 @@ func TestSpawnSubTurn_TargetAgentID_EmptyModelAccepted(t *testing.T) { t.Fatal("expected non-nil result") } } + +func TestDelegateToolNotRegistered_SingleAgent(t *testing.T) { + // Single-agent setup: delegate should not be registered + al, _, _, provider, cleanup := newTestAgentLoop(t) + _ = provider + defer cleanup() + + agent := al.registry.GetDefaultAgent() + if agent == nil { + t.Fatal("default agent should exist") + } + if _, has := agent.Tools.Get("delegate"); has { + t.Error("delegate tool should not be registered in single-agent setup") + } +} + +func TestDelegateToolRegistered_MultiAgent(t *testing.T) { + al, cleanup := newMultiAgentLoop(t, &mockProvider{}) + defer cleanup() + + // Both agents should have the delegate tool + for _, id := range []string{"alpha", "beta"} { + agent, ok := al.registry.GetAgent(id) + if !ok { + t.Fatalf("agent %q not found", id) + } + if _, has := agent.Tools.Get("delegate"); !has { + t.Errorf("agent %q should have delegate tool in multi-agent setup", id) + } + } +} From 06fad9571959df0d908c8a7dc48d70b3c39a3326 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Sat, 25 Apr 2026 19:08:46 +0600 Subject: [PATCH 10/87] 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 11/87] 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 12/87] 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 13/87] 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 14/87] 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 15/87] 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 16/87] 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 17/87] 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 18/87] 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 19/87] 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 20/87] 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 21/87] 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 22/87] 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 23/87] 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 24/87] 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 25/87] 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 26/87] 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 27/87] 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 28/87] 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 29/87] 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 30/87] 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 31/87] 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 32/87] 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 33/87] 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 34/87] 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 35/87] 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 36/87] 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 37/87] 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 38/87] 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 0161298154e7800f75bbff7fb23474b2f7541807 Mon Sep 17 00:00:00 2001 From: Guoguo <16666742+imguoguo@users.noreply.github.com> Date: Mon, 27 Apr 2026 17:15:02 +0800 Subject: [PATCH 39/87] ci: add stale bot to auto-close inactive issues and PRs (#2685) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two-phase strategy: 7 days inactive → stale warning, 7 more days → close. Exempt labels: pinned, keep-open, wip, do-not-close, type: roadmap. Draft PRs are also exempt. Runs daily at 03:00 JST. Scan oldest items first (ascending: true) with 500 ops budget to avoid backlog starvation. Co-authored-by: Claude Opus 4.6 --- .github/workflows/stale.yml | 64 +++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 .github/workflows/stale.yml diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml new file mode 100644 index 000000000..f454f5977 --- /dev/null +++ b/.github/workflows/stale.yml @@ -0,0 +1,64 @@ +name: Close stale issues and PRs + +on: + schedule: + # Run daily at 03:00 JST (18:00 UTC) + - cron: "0 18 * * *" + workflow_dispatch: + +permissions: + issues: write + pull-requests: write + +jobs: + stale: + runs-on: ubuntu-latest + + steps: + - name: Mark and close stale issues and PRs + uses: actions/stale@v10 + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + + # ── Issue: 7 days inactive → stale; 7 more days → close ── + days-before-issue-stale: 7 + days-before-issue-close: 7 + stale-issue-label: "stale" + stale-issue-message: > + This issue has had no activity for 7 days and has been marked as stale. + If it is still relevant, please reply or update; otherwise it will be + closed automatically in 7 days. + close-issue-message: > + This issue has been closed after 14 days of inactivity. + If it is still needed, feel free to reopen it anytime. + close-issue-reason: "not_planned" + + # ── PR: 7 days inactive → stale; 7 more days → close ── + days-before-pr-stale: 7 + days-before-pr-close: 7 + stale-pr-label: "stale" + stale-pr-message: > + This PR has had no activity for 7 days and has been marked as stale. + If you are still working on it, please push an update or leave a comment; + otherwise it will be closed automatically in 7 days. + close-pr-message: > + This PR has been closed after 14 days of inactivity. + If you would like to continue, feel free to reopen it or submit a new PR. + + # ── Protected labels (exempt from stale processing) ── + exempt-issue-labels: "pinned,keep-open,wip,do-not-close,type: roadmap" + exempt-pr-labels: "pinned,keep-open,wip,do-not-close,type: roadmap" + + # ── Exempt draft PRs ── + exempt-draft-pr: true + + # ── Remove stale label when activity resumes ── + remove-stale-when-updated: true + remove-issue-stale-when-updated: true + remove-pr-stale-when-updated: true + + # ── Scan oldest items first so old stale items are not starved ── + ascending: true + + # ── Throttle: max operations per run ── + operations-per-run: 500 From 97b1c3efecc2d5f9050566f4e15596263a743ff7 Mon Sep 17 00:00:00 2001 From: David Siewert Date: Mon, 27 Apr 2026 15:42:18 +0600 Subject: [PATCH 40/87] 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 41/87] 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 42/87] 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 43/87] 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 0bb0fc429a260e2dffdb95868191bd573d60e155 Mon Sep 17 00:00:00 2001 From: afjcjsbx Date: Mon, 27 Apr 2026 13:17:25 +0200 Subject: [PATCH 44/87] fix(cron): propagate sessionKey to prevent duplicate tool responses --- pkg/tools/cron.go | 2 +- pkg/tools/cron_test.go | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/pkg/tools/cron.go b/pkg/tools/cron.go index f2e6561df..a9547eba9 100644 --- a/pkg/tools/cron.go +++ b/pkg/tools/cron.go @@ -357,7 +357,7 @@ func (t *CronTool) ExecuteJob(ctx context.Context, job *cron.CronJob) string { } if response != "" { - t.executor.PublishResponseIfNeeded(ctx, channel, chatID, "", response) + t.executor.PublishResponseIfNeeded(ctx, channel, chatID, sessionKey, response) } return "ok" } diff --git a/pkg/tools/cron_test.go b/pkg/tools/cron_test.go index d46d365a0..0e527c98a 100644 --- a/pkg/tools/cron_test.go +++ b/pkg/tools/cron_test.go @@ -24,6 +24,7 @@ type stubJobExecutor struct { publishedResp string publishedChan string publishedChatID string + publishedKey string } func (s *stubJobExecutor) ProcessDirectWithChannel( @@ -47,6 +48,7 @@ func (s *stubJobExecutor) PublishResponseIfNeeded( s.publishedResp = response s.publishedChan = channel s.publishedChatID = chatID + s.publishedKey = sessionKey } func newTestCronToolWithExecutorAndConfig(t *testing.T, executor JobExecutor, cfg *config.Config) *CronTool { @@ -283,6 +285,9 @@ func TestCronTool_ExecuteJobPublishesAgentResponse(t *testing.T) { if executor.publishedResp != "generated reply" { t.Fatalf("published response = %q, want generated reply", executor.publishedResp) } + if executor.publishedKey != executor.lastKey { + t.Fatalf("published sessionKey = %q, want %q", executor.publishedKey, executor.lastKey) + } if executor.publishedChan != "telegram" || executor.publishedChatID != "chat-1" { t.Fatalf("published target = %s/%s, want telegram/chat-1", executor.publishedChan, executor.publishedChatID) } From cd7717bc155a440c06d42dad4c1b9c4aaed1d83b Mon Sep 17 00:00:00 2001 From: afjcjsbx Date: Mon, 27 Apr 2026 21:10:30 +0200 Subject: [PATCH 45/87] 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 46/87] 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 47/87] 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 c44bd6138cf3ce272c3810cf9a864b8417f55f33 Mon Sep 17 00:00:00 2001 From: LC <64722907+lc6464@users.noreply.github.com> Date: Tue, 28 Apr 2026 10:17:12 +0800 Subject: [PATCH 48/87] refactor(pico): unify message kind handling of tool_calls and thought (#2680) * refactor(pico): unify message kind handling of tool_calls and thought * fix(pico): add legacy compatibility for thought payload in Send method Co-authored-by: Copilot --------- Co-authored-by: Copilot --- pkg/channels/pico/client_test.go | 53 +++++++++++++++++-- pkg/channels/pico/pico.go | 13 +++-- pkg/channels/pico/pico_test.go | 45 +++++++++++++++- pkg/channels/pico/protocol.go | 12 ++++- .../features/chat/assistant-message-state.ts | 18 +++++-- 5 files changed, 126 insertions(+), 15 deletions(-) diff --git a/pkg/channels/pico/client_test.go b/pkg/channels/pico/client_test.go index 5ee028bae..2b167e457 100644 --- a/pkg/channels/pico/client_test.go +++ b/pkg/channels/pico/client_test.go @@ -333,18 +333,33 @@ func TestIsThoughtPayload(t *testing.T) { want bool }{ { - name: "explicit thought bool", + name: "explicit thought kind", + payload: map[string]any{PayloadKeyKind: MessageKindThought}, + want: true, + }, + { + name: "thought kind ignores case and whitespace", + payload: map[string]any{PayloadKeyKind: " ThOuGhT "}, + want: true, + }, + { + name: "legacy thought bool remains supported for inbound compatibility", payload: map[string]any{PayloadKeyThought: true}, want: true, }, { - name: "thought false", + name: "legacy thought false", payload: map[string]any{PayloadKeyThought: false}, want: false, }, { - name: "thought string ignored", - payload: map[string]any{PayloadKeyThought: "true"}, + name: "tool calls kind", + payload: map[string]any{PayloadKeyKind: MessageKindToolCalls}, + want: false, + }, + { + name: "non-string kind ignored", + payload: map[string]any{PayloadKeyKind: true}, want: false, }, { @@ -380,7 +395,7 @@ func TestPicoClientChannel_HandleServerMessage_IgnoresThought(t *testing.T) { Type: TypeMessageCreate, Payload: map[string]any{ PayloadKeyContent: "internal reasoning", - PayloadKeyThought: true, + PayloadKeyKind: MessageKindThought, }, }) @@ -390,3 +405,31 @@ func TestPicoClientChannel_HandleServerMessage_IgnoresThought(t *testing.T) { case <-time.After(150 * time.Millisecond): } } + +func TestPicoClientChannel_HandleServerMessage_IgnoresLegacyThoughtBool(t *testing.T) { + mb := bus.NewMessageBus() + bc := &config.Channel{Type: config.ChannelPicoClient, Enabled: true} + ch, err := NewPicoClientChannel(bc, &config.PicoClientSettings{ + URL: "ws://localhost:8080/ws", + }, mb) + if err != nil { + t.Fatalf("NewPicoClientChannel() error = %v", err) + } + + ch.ctx = context.Background() + pc := &picoConn{sessionID: "sess-thought-legacy"} + + ch.handleServerMessage(pc, PicoMessage{ + Type: TypeMessageCreate, + Payload: map[string]any{ + PayloadKeyContent: "legacy internal reasoning", + PayloadKeyThought: true, + }, + }) + + select { + case msg := <-mb.InboundChan(): + t.Fatalf("expected no inbound publish for legacy thought payload, got %+v", msg) + case <-time.After(150 * time.Millisecond): + } +} diff --git a/pkg/channels/pico/pico.go b/pkg/channels/pico/pico.go index 9bd8a5b5d..d1de8f4d5 100644 --- a/pkg/channels/pico/pico.go +++ b/pkg/channels/pico/pico.go @@ -323,10 +323,18 @@ func (c *PicoChannel) Send(ctx context.Context, msg bus.OutboundMessage) ([]stri payload := map[string]any{ PayloadKeyContent: content, - PayloadKeyThought: isThought, "message_id": msgID, } - if isToolCalls { + switch { + case isThought: + payload[PayloadKeyKind] = MessageKindThought + + // This field is kept solely for compatibility with legacy pico clients that + // do not yet support the newer "kind" field. + // DO NOT use it for any purpose other than legacy client compatibility. + payload[PayloadKeyThought] = true + + case isToolCalls: payload[PayloadKeyKind] = MessageKindToolCalls if toolCalls, ok := picoToolCallsPayload(msg); ok { payload[PayloadKeyToolCalls] = toolCalls @@ -457,7 +465,6 @@ func (c *PicoChannel) SendPlaceholder(ctx context.Context, chatID string) (strin msgID := uuid.New().String() outMsg := newMessage(TypeMessageCreate, map[string]any{ PayloadKeyContent: text, - PayloadKeyThought: false, "message_id": msgID, }) diff --git a/pkg/channels/pico/pico_test.go b/pkg/channels/pico/pico_test.go index 22ed5451a..bbe73a222 100644 --- a/pkg/channels/pico/pico_test.go +++ b/pkg/channels/pico/pico_test.go @@ -131,8 +131,8 @@ func TestSend_ThoughtMessageDoesNotFinalizeTrackedToolFeedback(t *testing.T) { if got := payload[PayloadKeyContent]; got != "thinking trace" { t.Fatalf("thought content = %#v, want %q", got, "thinking trace") } - if got := payload[PayloadKeyThought]; got != true { - t.Fatalf("thought flag = %#v, want true", got) + if got := payload[PayloadKeyKind]; got != MessageKindThought { + t.Fatalf("thought kind = %#v, want %q", got, MessageKindThought) } if got := payload["message_id"]; got == "msg-progress" || got == nil || got == "" { t.Fatalf("thought message_id = %#v, want new non-progress id", got) @@ -193,6 +193,47 @@ func TestSend_ThoughtMessageDoesNotFinalizeTrackedToolFeedback(t *testing.T) { } } +func TestSendPlaceholder_EmitsNormalMessageWithoutKind(t *testing.T) { + ch := newTestPicoChannel(t) + ch.bc.Placeholder.Enabled = true + + if err := ch.Start(context.Background()); err != nil { + t.Fatalf("Start() error = %v", err) + } + defer ch.Stop(context.Background()) + + clientConn, received, cleanup := newTestPicoWebSocket(t) + defer cleanup() + ch.addConnForTest(&picoConn{id: "conn-1", conn: clientConn, sessionID: "sess-1"}) + + msgID, err := ch.SendPlaceholder(context.Background(), "pico:sess-1") + if err != nil { + t.Fatalf("SendPlaceholder() error = %v", err) + } + if msgID == "" { + t.Fatal("expected placeholder message id") + } + + select { + case msg := <-received: + if msg.Type != TypeMessageCreate { + t.Fatalf("placeholder message type = %q, want %q", msg.Type, TypeMessageCreate) + } + payload := msg.Payload + if got := payload["message_id"]; got != msgID { + t.Fatalf("placeholder message_id = %#v, want %q", got, msgID) + } + if got := payload[PayloadKeyContent]; got != "Thinking..." { + t.Fatalf("placeholder content = %#v, want %q", got, "Thinking...") + } + if got, ok := payload[PayloadKeyKind]; ok { + t.Fatalf("placeholder kind = %#v, want absent", got) + } + case <-time.After(time.Second): + t.Fatal("expected placeholder message to be delivered") + } +} + func TestCreateAndAddConnection_RespectsMaxConnectionsConcurrently(t *testing.T) { ch := newTestPicoChannel(t) diff --git a/pkg/channels/pico/protocol.go b/pkg/channels/pico/protocol.go index 46e8fa3ee..6e3a5ca89 100644 --- a/pkg/channels/pico/protocol.go +++ b/pkg/channels/pico/protocol.go @@ -1,6 +1,9 @@ package pico -import "time" +import ( + "strings" + "time" +) // Protocol message types. const ( @@ -47,6 +50,13 @@ func newMessage(msgType string, payload map[string]any) PicoMessage { } func isThoughtPayload(payload map[string]any) bool { + kind, _ := payload[PayloadKeyKind].(string) + if strings.EqualFold(strings.TrimSpace(kind), MessageKindThought) { + return true + } + + // Keep pico_client inbound-compatible with legacy servers that still send + // the pre-kind boolean thought marker. thought, _ := payload[PayloadKeyThought].(bool) return thought } diff --git a/web/frontend/src/features/chat/assistant-message-state.ts b/web/frontend/src/features/chat/assistant-message-state.ts index 54eb6163f..c26b2665c 100644 --- a/web/frontend/src/features/chat/assistant-message-state.ts +++ b/web/frontend/src/features/chat/assistant-message-state.ts @@ -19,14 +19,25 @@ export interface AssistantMessageUpdateState { toolCalls?: AssistantToolCalls } +function normalizeAssistantMessageKind( + payload: Record, +): string | undefined { + if (typeof payload.kind !== "string") { + return undefined + } + const kind = payload.kind.trim().toLowerCase() + return kind || undefined +} + function parseAssistantMessageKind( payload: Record, toolCalls?: AssistantToolCalls, ): AssistantMessageKind { - if (payload.thought === true) { + const kind = normalizeAssistantMessageKind(payload) + if (kind === "thought") { return "thought" } - if (payload.kind === "tool_calls" || toolCalls) { + if (kind === "tool_calls" || toolCalls) { return "tool_calls" } return "normal" @@ -36,8 +47,7 @@ function hasExplicitAssistantKindPayload( payload: Record, ): boolean { return ( - typeof payload.thought === "boolean" || - payload.kind === "tool_calls" || + normalizeAssistantMessageKind(payload) !== undefined || payload.tool_calls !== undefined ) } From 0f52076762692521013c36d4e77da9a3cf463465 Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Sun, 26 Apr 2026 12:43:50 +0800 Subject: [PATCH 49/87] feat(tools): add cross-platform serial hardware tool --- pkg/tools/facade_compat_test.go | 3 + pkg/tools/hardware/serial.go | 332 +++++++++++++++++++++++++++ pkg/tools/hardware/serial_darwin.go | 19 ++ pkg/tools/hardware/serial_linux.go | 19 ++ pkg/tools/hardware/serial_other.go | 20 ++ pkg/tools/hardware/serial_test.go | 66 ++++++ pkg/tools/hardware/serial_unix.go | 263 +++++++++++++++++++++ pkg/tools/hardware/serial_windows.go | 214 +++++++++++++++++ pkg/tools/hardware_facade.go | 9 +- 9 files changed, 943 insertions(+), 2 deletions(-) create mode 100644 pkg/tools/hardware/serial.go create mode 100644 pkg/tools/hardware/serial_darwin.go create mode 100644 pkg/tools/hardware/serial_linux.go create mode 100644 pkg/tools/hardware/serial_other.go create mode 100644 pkg/tools/hardware/serial_test.go create mode 100644 pkg/tools/hardware/serial_unix.go create mode 100644 pkg/tools/hardware/serial_windows.go diff --git a/pkg/tools/facade_compat_test.go b/pkg/tools/facade_compat_test.go index 672554209..378462512 100644 --- a/pkg/tools/facade_compat_test.go +++ b/pkg/tools/facade_compat_test.go @@ -9,6 +9,9 @@ func TestFacadeConstructorsRemainAvailable(t *testing.T) { if NewSPITool() == nil { t.Fatal("NewSPITool should return a tool") } + if NewSerialTool() == nil { + t.Fatal("NewSerialTool should return a tool") + } if NewMessageTool() == nil { t.Fatal("NewMessageTool should return a tool") } diff --git a/pkg/tools/hardware/serial.go b/pkg/tools/hardware/serial.go new file mode 100644 index 000000000..3f55da362 --- /dev/null +++ b/pkg/tools/hardware/serial.go @@ -0,0 +1,332 @@ +package hardwaretools + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + "unicode/utf8" +) + +const ( + defaultSerialBaud = 115200 + defaultSerialDataBits = 8 + defaultSerialStopBits = 1 + defaultSerialTimeoutMS = 1000 + maxSerialPayloadBytes = 4096 + maxSerialReadBytes = 4096 +) + +type SerialTool struct{} + +type serialPortInfo struct { + Name string `json:"name"` + Path string `json:"path"` +} + +type serialConfig struct { + Port string + Baud int + DataBits int + Parity string + StopBits int +} + +func NewSerialTool() *SerialTool { + return &SerialTool{} +} + +func (t *SerialTool) Name() string { + return "serial" +} + +func (t *SerialTool) Description() string { + return "Interact with host serial ports. Actions: list (enumerate ports), read (receive bytes), write (send bytes with explicit confirmation). Supports Linux, macOS, and Windows." +} + +func (t *SerialTool) Parameters() map[string]any { + return map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"list", "read", "write"}, + "description": "Action to perform: list available serial ports, read bytes from a port, or write bytes to a port.", + }, + "port": map[string]any{ + "type": "string", + "description": "Serial port path or name, for example /dev/ttyUSB0, /dev/cu.usbserial-0001, or COM3. Required for read/write.", + }, + "baud": map[string]any{ + "type": "integer", + "description": "Baud rate. Default: 115200.", + }, + "data_bits": map[string]any{ + "type": "integer", + "description": "Data bits. Supported values: 5, 6, 7, 8. Default: 8.", + }, + "parity": map[string]any{ + "type": "string", + "enum": []string{"none", "even", "odd"}, + "description": "Parity mode. Default: none.", + }, + "stop_bits": map[string]any{ + "type": "integer", + "description": "Stop bits. Supported values: 1, 2. Default: 1.", + }, + "timeout_ms": map[string]any{ + "type": "integer", + "description": "Read/write timeout in milliseconds. Default: 1000.", + }, + "length": map[string]any{ + "type": "integer", + "description": "Number of bytes to read. Required for read. Range: 1-4096.", + }, + "data": map[string]any{ + "type": "array", + "items": map[string]any{"type": "integer"}, + "description": "Bytes to write, each in range 0-255. Required for write unless text is provided.", + }, + "text": map[string]any{ + "type": "string", + "description": "UTF-8 text to write. Required for write if data is omitted.", + }, + "confirm": map[string]any{ + "type": "boolean", + "description": "Must be true for write operations.", + }, + }, + "required": []string{"action"}, + } +} + +func (t *SerialTool) Execute(ctx context.Context, args map[string]any) *ToolResult { + action, ok := args["action"].(string) + if !ok || strings.TrimSpace(action) == "" { + return ErrorResult("action is required") + } + + switch action { + case "list": + return t.list() + case "read": + return t.read(args) + case "write": + return t.write(args) + default: + return ErrorResult(fmt.Sprintf("unknown action: %s (valid: list, read, write)", action)) + } +} + +func (t *SerialTool) list() *ToolResult { + ports, err := serialListPorts() + if err != nil { + return ErrorResult(fmt.Sprintf("failed to list serial ports: %v", err)) + } + if len(ports) == 0 { + return SilentResult("No serial ports found on this host.") + } + + result, _ := json.MarshalIndent(map[string]any{ + "ports": ports, + "count": len(ports), + }, "", " ") + return SilentResult(string(result)) +} + +func (t *SerialTool) read(args map[string]any) *ToolResult { + cfg, errResult := parseSerialConfig(args) + if errResult != nil { + return errResult + } + + length := 0 + if v, ok := args["length"].(float64); ok { + length = int(v) + } + if length < 1 || length > maxSerialReadBytes { + return ErrorResult(fmt.Sprintf("length is required for read (1-%d)", maxSerialReadBytes)) + } + + timeout, errResult := parseSerialTimeout(args) + if errResult != nil { + return errResult + } + + data, err := serialRead(cfg, length, timeout) + if err != nil { + return ErrorResult(fmt.Sprintf("serial read failed on %s: %v", cfg.Port, err)) + } + + return SilentResult(formatSerialPayload("read", cfg, data, timeout)) +} + +func (t *SerialTool) write(args map[string]any) *ToolResult { + confirm, _ := args["confirm"].(bool) + if !confirm { + return ErrorResult( + "write operations require confirm: true. Please confirm with the user before sending bytes to a serial device.", + ) + } + + cfg, errResult := parseSerialConfig(args) + if errResult != nil { + return errResult + } + timeout, errResult := parseSerialTimeout(args) + if errResult != nil { + return errResult + } + payload, errResult := parseSerialWritePayload(args) + if errResult != nil { + return errResult + } + + written, err := serialWrite(cfg, payload, timeout) + if err != nil { + return ErrorResult(fmt.Sprintf("serial write failed on %s: %v", cfg.Port, err)) + } + + result, _ := json.MarshalIndent(map[string]any{ + "action": "write", + "port": cfg.Port, + "baud": cfg.Baud, + "data_bits": cfg.DataBits, + "parity": cfg.Parity, + "stop_bits": cfg.StopBits, + "timeout_ms": timeout.Milliseconds(), + "written": written, + "payload": serialPayloadSummary(payload), + }, "", " ") + return SilentResult(string(result)) +} + +func parseSerialConfig(args map[string]any) (serialConfig, *ToolResult) { + port, ok := args["port"].(string) + port = strings.TrimSpace(port) + if !ok || port == "" { + return serialConfig{}, ErrorResult("port is required (for example /dev/ttyUSB0, /dev/cu.usbserial-0001, or COM3)") + } + + cfg := serialConfig{ + Port: port, + Baud: defaultSerialBaud, + DataBits: defaultSerialDataBits, + Parity: "none", + StopBits: defaultSerialStopBits, + } + + if v, ok := args["baud"].(float64); ok { + cfg.Baud = int(v) + } + if cfg.Baud < 50 || cfg.Baud > 4000000 { + return serialConfig{}, ErrorResult("baud must be between 50 and 4000000") + } + + if v, ok := args["data_bits"].(float64); ok { + cfg.DataBits = int(v) + } + switch cfg.DataBits { + case 5, 6, 7, 8: + default: + return serialConfig{}, ErrorResult("data_bits must be one of 5, 6, 7, or 8") + } + + if v, ok := args["parity"].(string); ok && strings.TrimSpace(v) != "" { + cfg.Parity = strings.ToLower(strings.TrimSpace(v)) + } + switch cfg.Parity { + case "none", "even", "odd": + default: + return serialConfig{}, ErrorResult(`parity must be one of "none", "even", or "odd"`) + } + + if v, ok := args["stop_bits"].(float64); ok { + cfg.StopBits = int(v) + } + if cfg.StopBits != 1 && cfg.StopBits != 2 { + return serialConfig{}, ErrorResult("stop_bits must be 1 or 2") + } + + return cfg, nil +} + +func parseSerialTimeout(args map[string]any) (time.Duration, *ToolResult) { + timeoutMS := defaultSerialTimeoutMS + if v, ok := args["timeout_ms"].(float64); ok { + timeoutMS = int(v) + } + if timeoutMS < 1 || timeoutMS > 60000 { + return 0, ErrorResult("timeout_ms must be between 1 and 60000") + } + return time.Duration(timeoutMS) * time.Millisecond, nil +} + +func parseSerialWritePayload(args map[string]any) ([]byte, *ToolResult) { + if text, ok := args["text"].(string); ok && text != "" { + if !utf8.ValidString(text) { + return nil, ErrorResult("text must be valid UTF-8") + } + if len(text) > maxSerialPayloadBytes { + return nil, ErrorResult(fmt.Sprintf("text payload too large: maximum %d bytes", maxSerialPayloadBytes)) + } + return []byte(text), nil + } + + dataRaw, ok := args["data"].([]any) + if !ok || len(dataRaw) == 0 { + return nil, ErrorResult("write requires either text or data") + } + if len(dataRaw) > maxSerialPayloadBytes { + return nil, ErrorResult(fmt.Sprintf("data too long: maximum %d bytes", maxSerialPayloadBytes)) + } + + data := make([]byte, len(dataRaw)) + for i, v := range dataRaw { + f, ok := v.(float64) + if !ok { + return nil, ErrorResult(fmt.Sprintf("data[%d] is not a valid byte value", i)) + } + b := int(f) + if b < 0 || b > 255 { + return nil, ErrorResult(fmt.Sprintf("data[%d] = %d is out of byte range (0-255)", i, b)) + } + data[i] = byte(b) + } + + return data, nil +} + +func formatSerialPayload(action string, cfg serialConfig, data []byte, timeout time.Duration) string { + result, _ := json.MarshalIndent(map[string]any{ + "action": action, + "port": cfg.Port, + "baud": cfg.Baud, + "data_bits": cfg.DataBits, + "parity": cfg.Parity, + "stop_bits": cfg.StopBits, + "timeout_ms": timeout.Milliseconds(), + "payload": serialPayloadSummary(data), + }, "", " ") + return string(result) +} + +func serialPayloadSummary(data []byte) map[string]any { + hexValues := make([]string, len(data)) + intValues := make([]int, len(data)) + for i, b := range data { + hexValues[i] = fmt.Sprintf("0x%02x", b) + intValues[i] = int(b) + } + + summary := map[string]any{ + "length": len(data), + "bytes": intValues, + "hex": hexValues, + } + if utf8.Valid(data) { + summary["text"] = string(data) + } + return summary +} diff --git a/pkg/tools/hardware/serial_darwin.go b/pkg/tools/hardware/serial_darwin.go new file mode 100644 index 000000000..f6cf30db4 --- /dev/null +++ b/pkg/tools/hardware/serial_darwin.go @@ -0,0 +1,19 @@ +//go:build darwin + +package hardwaretools + +import "golang.org/x/sys/unix" + +func serialGetTermios(fd int) (*unix.Termios, error) { + return unix.IoctlGetTermios(fd, unix.TIOCGETA) +} + +func serialSetSpeed(tio *unix.Termios, speed uint32) error { + tio.Ispeed = speed + tio.Ospeed = speed + return nil +} + +func serialSetTermios(fd int, tio *unix.Termios) error { + return unix.IoctlSetTermios(fd, unix.TIOCSETA, tio) +} diff --git a/pkg/tools/hardware/serial_linux.go b/pkg/tools/hardware/serial_linux.go new file mode 100644 index 000000000..bad3e4cb8 --- /dev/null +++ b/pkg/tools/hardware/serial_linux.go @@ -0,0 +1,19 @@ +//go:build linux + +package hardwaretools + +import "golang.org/x/sys/unix" + +func serialGetTermios(fd int) (*unix.Termios, error) { + return unix.IoctlGetTermios(fd, unix.TCGETS) +} + +func serialSetSpeed(tio *unix.Termios, speed uint32) error { + tio.Ispeed = speed + tio.Ospeed = speed + return nil +} + +func serialSetTermios(fd int, tio *unix.Termios) error { + return unix.IoctlSetTermios(fd, unix.TCSETS, tio) +} diff --git a/pkg/tools/hardware/serial_other.go b/pkg/tools/hardware/serial_other.go new file mode 100644 index 000000000..f57ce2fa3 --- /dev/null +++ b/pkg/tools/hardware/serial_other.go @@ -0,0 +1,20 @@ +//go:build !linux && !darwin && !windows + +package hardwaretools + +import ( + "fmt" + "time" +) + +func serialListPorts() ([]serialPortInfo, error) { + return nil, nil +} + +func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { + return nil, fmt.Errorf("serial is not supported on this platform") +} + +func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, error) { + return 0, fmt.Errorf("serial is not supported on this platform") +} diff --git a/pkg/tools/hardware/serial_test.go b/pkg/tools/hardware/serial_test.go new file mode 100644 index 000000000..68657dffd --- /dev/null +++ b/pkg/tools/hardware/serial_test.go @@ -0,0 +1,66 @@ +package hardwaretools + +import ( + "testing" + "time" +) + +func TestParseSerialConfig(t *testing.T) { + cfg, errResult := parseSerialConfig(map[string]any{ + "port": "COM3", + "baud": float64(9600), + "data_bits": float64(7), + "parity": "even", + "stop_bits": float64(2), + }) + if errResult != nil { + t.Fatalf("parseSerialConfig() unexpected error = %v", errResult.ForLLM) + } + + if cfg.Port != "COM3" || cfg.Baud != 9600 || cfg.DataBits != 7 || cfg.Parity != "even" || cfg.StopBits != 2 { + t.Fatalf("parseSerialConfig() = %#v", cfg) + } +} + +func TestParseSerialConfigRejectsInvalidParity(t *testing.T) { + _, errResult := parseSerialConfig(map[string]any{ + "port": "/dev/ttyUSB0", + "parity": "mark", + }) + if errResult == nil { + t.Fatal("expected invalid parity to fail") + } +} + +func TestParseSerialTimeout(t *testing.T) { + timeout, errResult := parseSerialTimeout(map[string]any{ + "timeout_ms": float64(2500), + }) + if errResult != nil { + t.Fatalf("parseSerialTimeout() unexpected error = %v", errResult.ForLLM) + } + if timeout != 2500*time.Millisecond { + t.Fatalf("timeout = %v, want 2500ms", timeout) + } +} + +func TestParseSerialWritePayloadSupportsText(t *testing.T) { + data, errResult := parseSerialWritePayload(map[string]any{ + "text": "AT\r\n", + }) + if errResult != nil { + t.Fatalf("parseSerialWritePayload() unexpected error = %v", errResult.ForLLM) + } + if string(data) != "AT\r\n" { + t.Fatalf("payload = %q, want %q", string(data), "AT\r\n") + } +} + +func TestParseSerialWritePayloadRejectsOutOfRangeByte(t *testing.T) { + _, errResult := parseSerialWritePayload(map[string]any{ + "data": []any{float64(256)}, + }) + if errResult == nil { + t.Fatal("expected payload validation failure") + } +} diff --git a/pkg/tools/hardware/serial_unix.go b/pkg/tools/hardware/serial_unix.go new file mode 100644 index 000000000..caef7e0e8 --- /dev/null +++ b/pkg/tools/hardware/serial_unix.go @@ -0,0 +1,263 @@ +//go:build linux || darwin + +package hardwaretools + +import ( + "fmt" + "os" + "path/filepath" + "sort" + "strings" + "time" + + "golang.org/x/sys/unix" +) + +func serialListPorts() ([]serialPortInfo, error) { + patterns := []string{ + "/dev/ttyS*", + "/dev/ttyUSB*", + "/dev/ttyACM*", + "/dev/ttyAMA*", + "/dev/rfcomm*", + "/dev/tty.*", + "/dev/cu.*", + } + + seen := make(map[string]struct{}) + ports := make([]serialPortInfo, 0) + for _, pattern := range patterns { + matches, err := filepath.Glob(pattern) + if err != nil { + return nil, err + } + for _, match := range matches { + if _, ok := seen[match]; ok { + continue + } + info, err := os.Stat(match) + if err != nil || info.IsDir() { + continue + } + seen[match] = struct{}{} + ports = append(ports, serialPortInfo{ + Name: filepath.Base(match), + Path: match, + }) + } + } + + sort.Slice(ports, func(i, j int) bool { + return ports[i].Path < ports[j].Path + }) + return ports, nil +} + +func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { + fd, err := openAndConfigureSerialPort(cfg) + if err != nil { + return nil, err + } + defer unix.Close(fd) + + buf := make([]byte, length) + total := 0 + deadline := time.Now().Add(timeout) + + for total < length { + remaining := time.Until(deadline) + if remaining <= 0 { + break + } + + n, err := pollRead(fd, buf[total:], remaining) + if err != nil { + return nil, err + } + if n == 0 { + break + } + total += n + } + + return buf[:total], nil +} + +func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, error) { + fd, err := openAndConfigureSerialPort(cfg) + if err != nil { + return 0, err + } + defer unix.Close(fd) + + total := 0 + deadline := time.Now().Add(timeout) + for total < len(data) { + remaining := time.Until(deadline) + if remaining <= 0 { + return total, fmt.Errorf("timeout while writing serial data") + } + + n, err := pollWrite(fd, data[total:], remaining) + if err != nil { + return total, err + } + if n == 0 { + return total, fmt.Errorf("serial port accepted zero bytes") + } + total += n + } + + return total, nil +} + +func openAndConfigureSerialPort(cfg serialConfig) (int, error) { + fd, err := unix.Open(normalizeUnixSerialPath(cfg.Port), unix.O_RDWR|unix.O_NOCTTY|unix.O_NONBLOCK, 0) + if err != nil { + return -1, err + } + + if err := unix.SetNonblock(fd, false); err != nil { + unix.Close(fd) + return -1, err + } + + if err := configureUnixSerialPort(fd, cfg); err != nil { + unix.Close(fd) + return -1, err + } + + return fd, nil +} + +func configureUnixSerialPort(fd int, cfg serialConfig) error { + tio, err := serialGetTermios(fd) + if err != nil { + return err + } + + tio.Iflag = 0 + tio.Oflag = 0 + tio.Lflag = 0 + tio.Cflag = unix.CREAD | unix.CLOCAL + tio.Cc[unix.VMIN] = 0 + tio.Cc[unix.VTIME] = 0 + + switch cfg.DataBits { + case 5: + tio.Cflag |= unix.CS5 + case 6: + tio.Cflag |= unix.CS6 + case 7: + tio.Cflag |= unix.CS7 + default: + tio.Cflag |= unix.CS8 + } + + switch cfg.Parity { + case "even": + tio.Cflag |= unix.PARENB + case "odd": + tio.Cflag |= unix.PARENB | unix.PARODD + } + + if cfg.StopBits == 2 { + tio.Cflag |= unix.CSTOPB + } + + speed, err := serialBaudToUnix(cfg.Baud) + if err != nil { + return err + } + if err := serialSetSpeed(tio, speed); err != nil { + return err + } + + return serialSetTermios(fd, tio) +} + +func serialBaudToUnix(baud int) (uint32, error) { + switch baud { + case 50: + return unix.B50, nil + case 75: + return unix.B75, nil + case 110: + return unix.B110, nil + case 134: + return unix.B134, nil + case 150: + return unix.B150, nil + case 200: + return unix.B200, nil + case 300: + return unix.B300, nil + case 600: + return unix.B600, nil + case 1200: + return unix.B1200, nil + case 1800: + return unix.B1800, nil + case 2400: + return unix.B2400, nil + case 4800: + return unix.B4800, nil + case 9600: + return unix.B9600, nil + case 19200: + return unix.B19200, nil + case 38400: + return unix.B38400, nil + case 57600: + return unix.B57600, nil + case 115200: + return unix.B115200, nil + case 230400: + return unix.B230400, nil + default: + return 0, fmt.Errorf("unsupported baud rate on this platform: %d", baud) + } +} + +func pollRead(fd int, dst []byte, timeout time.Duration) (int, error) { + pfd := []unix.PollFd{{Fd: int32(fd), Events: unix.POLLIN}} + n, err := unix.Poll(pfd, durationToPollTimeout(timeout)) + if err != nil { + return 0, err + } + if n == 0 { + return 0, nil + } + return unix.Read(fd, dst) +} + +func pollWrite(fd int, src []byte, timeout time.Duration) (int, error) { + pfd := []unix.PollFd{{Fd: int32(fd), Events: unix.POLLOUT}} + n, err := unix.Poll(pfd, durationToPollTimeout(timeout)) + if err != nil { + return 0, err + } + if n == 0 { + return 0, nil + } + return unix.Write(fd, src) +} + +func durationToPollTimeout(timeout time.Duration) int { + if timeout <= 0 { + return 0 + } + ms := int(timeout / time.Millisecond) + if ms == 0 { + return 1 + } + return ms +} + +func normalizeUnixSerialPath(port string) string { + trimmed := strings.TrimSpace(port) + if strings.HasPrefix(trimmed, "/dev/") { + return trimmed + } + return "/dev/" + trimmed +} diff --git a/pkg/tools/hardware/serial_windows.go b/pkg/tools/hardware/serial_windows.go new file mode 100644 index 000000000..c4d119ac4 --- /dev/null +++ b/pkg/tools/hardware/serial_windows.go @@ -0,0 +1,214 @@ +//go:build windows + +package hardwaretools + +import ( + "fmt" + "path/filepath" + "sort" + "strings" + "time" + "unsafe" + + "golang.org/x/sys/windows" + "golang.org/x/sys/windows/registry" +) + +var ( + kernel32 = windows.NewLazySystemDLL("kernel32.dll") + procGetCommState = kernel32.NewProc("GetCommState") + procSetCommState = kernel32.NewProc("SetCommState") + procSetCommTimeouts = kernel32.NewProc("SetCommTimeouts") + procPurgeComm = kernel32.NewProc("PurgeComm") +) + +const ( + purgeTxClear = 0x0004 + purgeRxClear = 0x0008 +) + +type dcb struct { + DCBlength uint32 + BaudRate uint32 + Flags uint32 + Reserved uint16 + XonLim uint16 + XoffLim uint16 + ByteSize byte + Parity byte + StopBits byte + XonChar byte + XoffChar byte + ErrorChar byte + EofChar byte + EvtChar byte + wReserved1 uint16 +} + +type commTimeouts struct { + ReadIntervalTimeout uint32 + ReadTotalTimeoutMultiplier uint32 + ReadTotalTimeoutConstant uint32 + WriteTotalTimeoutMultiplier uint32 + WriteTotalTimeoutConstant uint32 +} + +func serialListPorts() ([]serialPortInfo, error) { + key, err := registry.OpenKey(registry.LOCAL_MACHINE, `HARDWARE\DEVICEMAP\SERIALCOMM`, registry.QUERY_VALUE) + if err != nil { + if err == registry.ErrNotExist { + return nil, nil + } + return nil, err + } + defer key.Close() + + names, err := key.ReadValueNames(-1) + if err != nil { + return nil, err + } + + ports := make([]serialPortInfo, 0, len(names)) + seen := make(map[string]struct{}) + for _, name := range names { + value, _, err := key.GetStringValue(name) + if err != nil { + continue + } + portName := strings.TrimSpace(value) + if portName == "" { + continue + } + normalized := strings.ToUpper(portName) + if _, ok := seen[normalized]; ok { + continue + } + seen[normalized] = struct{}{} + ports = append(ports, serialPortInfo{ + Name: normalized, + Path: normalized, + }) + } + + sort.Slice(ports, func(i, j int) bool { + return ports[i].Path < ports[j].Path + }) + return ports, nil +} + +func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { + handle, err := openAndConfigureWindowsSerial(cfg, timeout) + if err != nil { + return nil, err + } + defer windows.CloseHandle(handle) + + buf := make([]byte, length) + var read uint32 + if err := windows.ReadFile(handle, buf, &read, nil); err != nil { + return nil, err + } + return buf[:read], nil +} + +func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, error) { + handle, err := openAndConfigureWindowsSerial(cfg, timeout) + if err != nil { + return 0, err + } + defer windows.CloseHandle(handle) + + var written uint32 + if err := windows.WriteFile(handle, data, &written, nil); err != nil { + return int(written), err + } + return int(written), nil +} + +func openAndConfigureWindowsSerial(cfg serialConfig, timeout time.Duration) (windows.Handle, error) { + path := normalizeWindowsSerialPath(cfg.Port) + handle, err := windows.CreateFile( + windows.StringToUTF16Ptr(path), + windows.GENERIC_READ|windows.GENERIC_WRITE, + 0, + nil, + windows.OPEN_EXISTING, + 0, + 0, + ) + if err != nil { + return 0, err + } + + if err := configureWindowsSerialPort(handle, cfg, timeout); err != nil { + windows.CloseHandle(handle) + return 0, err + } + return handle, nil +} + +func configureWindowsSerialPort(handle windows.Handle, cfg serialConfig, timeout time.Duration) error { + state := dcb{DCBlength: uint32(unsafe.Sizeof(dcb{}))} + r1, _, err := procGetCommState.Call(uintptr(handle), uintptr(unsafe.Pointer(&state))) + if r1 == 0 { + return err + } + + state.BaudRate = uint32(cfg.Baud) + state.ByteSize = byte(cfg.DataBits) + state.Flags |= 0x00000001 // fBinary + + switch cfg.Parity { + case "even": + state.Parity = 2 + state.Flags |= 0x00000002 // fParity + case "odd": + state.Parity = 1 + state.Flags |= 0x00000002 // fParity + default: + state.Parity = 0 + state.Flags &^= 0x00000002 + } + + switch cfg.StopBits { + case 2: + state.StopBits = 2 + default: + state.StopBits = 0 + } + + r1, _, err = procSetCommState.Call(uintptr(handle), uintptr(unsafe.Pointer(&state))) + if r1 == 0 { + return err + } + + timeoutMS := uint32(timeout / time.Millisecond) + if timeoutMS == 0 { + timeoutMS = 1 + } + timeouts := commTimeouts{ + ReadIntervalTimeout: timeoutMS, + ReadTotalTimeoutConstant: timeoutMS, + WriteTotalTimeoutConstant: timeoutMS, + ReadTotalTimeoutMultiplier: 0, + WriteTotalTimeoutMultiplier: 0, + } + r1, _, err = procSetCommTimeouts.Call(uintptr(handle), uintptr(unsafe.Pointer(&timeouts))) + if r1 == 0 { + return err + } + + procPurgeComm.Call(uintptr(handle), uintptr(purgeRxClear|purgeTxClear)) + return nil +} + +func normalizeWindowsSerialPath(port string) string { + trimmed := strings.ToUpper(strings.TrimSpace(port)) + if strings.HasPrefix(trimmed, `\\.\`) { + return trimmed + } + if filepath.VolumeName(trimmed) != "" { + return trimmed + } + return `\\.\` + trimmed +} diff --git a/pkg/tools/hardware_facade.go b/pkg/tools/hardware_facade.go index f55d152cf..b505c5a48 100644 --- a/pkg/tools/hardware_facade.go +++ b/pkg/tools/hardware_facade.go @@ -3,8 +3,9 @@ package tools import hardwaretools "github.com/sipeed/picoclaw/pkg/tools/hardware" type ( - I2CTool = hardwaretools.I2CTool - SPITool = hardwaretools.SPITool + I2CTool = hardwaretools.I2CTool + SerialTool = hardwaretools.SerialTool + SPITool = hardwaretools.SPITool ) func NewI2CTool() *I2CTool { @@ -14,3 +15,7 @@ func NewI2CTool() *I2CTool { func NewSPITool() *SPITool { return hardwaretools.NewSPITool() } + +func NewSerialTool() *SerialTool { + return hardwaretools.NewSerialTool() +} From 2114e1a53fcd89e7beecfb27a1f9c4efee8a109b Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Sun, 26 Apr 2026 12:44:05 +0800 Subject: [PATCH 50/87] feat(config): wire serial tool into runtime and dashboard --- config/config.example.json | 3 ++ pkg/agent/agent_init.go | 3 ++ pkg/config/config.go | 3 ++ pkg/config/defaults.go | 3 ++ web/backend/api/tools.go | 22 +++++++++++ web/backend/api/tools_test.go | 57 +++++++++++++++++++++++++++ web/frontend/src/i18n/locales/en.json | 1 + web/frontend/src/i18n/locales/zh.json | 1 + 8 files changed, 93 insertions(+) diff --git a/config/config.example.json b/config/config.example.json index 30460c231..4205b8e8a 100644 --- a/config/config.example.json +++ b/config/config.example.json @@ -437,6 +437,9 @@ "enabled": true, "mode": "bytes" }, + "serial": { + "enabled": false + }, "send_tts": { "enabled": false }, diff --git a/pkg/agent/agent_init.go b/pkg/agent/agent_init.go index 611d634e8..335fd8537 100644 --- a/pkg/agent/agent_init.go +++ b/pkg/agent/agent_init.go @@ -128,6 +128,9 @@ func registerSharedTools( if cfg.Tools.IsToolEnabled("spi") { agent.Tools.Register(tools.NewSPITool()) } + if cfg.Tools.IsToolEnabled("serial") { + agent.Tools.Register(tools.NewSerialTool()) + } // Message tool if cfg.Tools.IsToolEnabled("message") { diff --git a/pkg/config/config.go b/pkg/config/config.go index 16497b4ac..dc9e88949 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -823,6 +823,7 @@ type ToolsConfig struct { ListDir ToolConfig `json:"list_dir" yaml:"-" envPrefix:"PICOCLAW_TOOLS_LIST_DIR_"` Message ToolConfig `json:"message" yaml:"-" envPrefix:"PICOCLAW_TOOLS_MESSAGE_"` ReadFile ReadFileToolConfig `json:"read_file" yaml:"-" envPrefix:"PICOCLAW_TOOLS_READ_FILE_"` + Serial ToolConfig `json:"serial" yaml:"-" envPrefix:"PICOCLAW_TOOLS_SERIAL_"` SendFile ToolConfig `json:"send_file" yaml:"-" envPrefix:"PICOCLAW_TOOLS_SEND_FILE_"` SendTTS ToolConfig `json:"send_tts" yaml:"-" envPrefix:"PICOCLAW_TOOLS_SEND_TTS_"` Spawn ToolConfig `json:"spawn" yaml:"-" envPrefix:"PICOCLAW_TOOLS_SPAWN_"` @@ -1548,6 +1549,8 @@ func (t *ToolsConfig) IsToolEnabled(name string) bool { return t.Message.Enabled case "read_file": return t.ReadFile.Enabled + case "serial": + return t.Serial.Enabled case "spawn": return t.Spawn.Enabled case "spawn_status": diff --git a/pkg/config/defaults.go b/pkg/config/defaults.go index f3aaca7ab..be8c32495 100644 --- a/pkg/config/defaults.go +++ b/pkg/config/defaults.go @@ -435,6 +435,9 @@ func DefaultConfig() *Config { Mode: ReadFileModeBytes, MaxReadFileSize: 64 * 1024, // 64KB }, + Serial: ToolConfig{ + Enabled: false, // Hardware tool - requires host serial ports + }, Spawn: ToolConfig{ Enabled: true, }, diff --git a/web/backend/api/tools.go b/web/backend/api/tools.go index c6c2deaae..3476e3c53 100644 --- a/web/backend/api/tools.go +++ b/web/backend/api/tools.go @@ -171,6 +171,12 @@ var toolCatalog = []toolCatalogEntry{ Category: "hardware", ConfigKey: "spi", }, + { + Name: "serial", + Description: "Interact with serial ports exposed on the host.", + Category: "hardware", + ConfigKey: "serial", + }, { Name: "tool_search_tool_regex", Description: "Discover hidden MCP tools by regex search when tool discovery is enabled.", @@ -265,6 +271,8 @@ func buildToolSupport(cfg *config.Config) []toolSupportItem { status, reasonCode = resolveWebSearchToolSupport(cfg) case "i2c", "spi": status, reasonCode = resolveHardwareToolSupport(cfg.Tools.IsToolEnabled(entry.ConfigKey)) + case "serial": + status, reasonCode = resolveSerialToolSupport(cfg.Tools.IsToolEnabled(entry.ConfigKey)) default: if cfg.Tools.IsToolEnabled(entry.ConfigKey) { status = "enabled" @@ -293,6 +301,18 @@ func resolveHardwareToolSupport(enabled bool) (string, string) { return "enabled", "" } +func resolveSerialToolSupport(enabled bool) (string, string) { + if !enabled { + return "disabled", "" + } + switch runtime.GOOS { + case "linux", "darwin", "windows": + return "enabled", "" + default: + return "blocked", "requires_serial_platform" + } +} + func resolveDiscoveryToolSupport(cfg *config.Config, methodEnabled bool) (string, string) { if !cfg.Tools.IsToolEnabled("mcp") { return "disabled", "" @@ -362,6 +382,8 @@ func applyToolState(cfg *config.Config, toolName string, enabled bool) error { cfg.Tools.I2C.Enabled = enabled case "spi": cfg.Tools.SPI.Enabled = enabled + case "serial": + cfg.Tools.Serial.Enabled = enabled case "tool_search_tool_regex": cfg.Tools.MCP.Discovery.UseRegex = enabled if enabled { diff --git a/web/backend/api/tools_test.go b/web/backend/api/tools_test.go index c98067e41..a09a49fd6 100644 --- a/web/backend/api/tools_test.go +++ b/web/backend/api/tools_test.go @@ -92,9 +92,36 @@ func TestHandleListTools(t *testing.T) { if gotTools["i2c"].Status != "disabled" { t.Fatalf("i2c status = %q, want disabled on linux when config is off", gotTools["i2c"].Status) } + if gotTools["serial"].Status != "disabled" { + t.Fatalf("serial status = %q, want disabled when config is off", gotTools["serial"].Status) + } + + cfg.Tools.Serial.Enabled = true + if err := config.SaveConfig(configPath, cfg); err != nil { + t.Fatalf("SaveConfig() error = %v", err) + } + + rec = httptest.NewRecorder() + req = httptest.NewRequest(http.MethodGet, "/api/tools", nil) + mux.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want %d, body=%s", rec.Code, http.StatusOK, rec.Body.String()) + } + + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatalf("Unmarshal() error = %v", err) + } + gotTools = make(map[string]toolSupportItem, len(resp.Tools)) + for _, tool := range resp.Tools { + gotTools[tool.Name] = tool + } + if gotTools["serial"].Status != "enabled" { + t.Fatalf("serial = %#v, want enabled on linux when config is on", gotTools["serial"]) + } } else { cfg.Tools.I2C.Enabled = true cfg.Tools.SPI.Enabled = true + cfg.Tools.Serial.Enabled = true if err := config.SaveConfig(configPath, cfg); err != nil { t.Fatalf("SaveConfig() error = %v", err) } @@ -120,6 +147,16 @@ func TestHandleListTools(t *testing.T) { if gotTools["spi"].Status != "blocked" || gotTools["spi"].ReasonCode != "requires_linux" { t.Fatalf("spi = %#v, want blocked/requires_linux", gotTools["spi"]) } + switch runtime.GOOS { + case "darwin", "windows": + if gotTools["serial"].Status != "enabled" { + t.Fatalf("serial = %#v, want enabled on supported host", gotTools["serial"]) + } + default: + if gotTools["serial"].Status != "blocked" || gotTools["serial"].ReasonCode != "requires_serial_platform" { + t.Fatalf("serial = %#v, want blocked/requires_serial_platform", gotTools["serial"]) + } + } } } @@ -195,6 +232,26 @@ func TestHandleUpdateToolState(t *testing.T) { if !updated.Tools.Cron.Enabled { t.Fatalf("cron should be enabled: %#v", updated.Tools.Cron) } + + rec4 := httptest.NewRecorder() + req4 := httptest.NewRequest( + http.MethodPut, + "/api/tools/serial/state", + bytes.NewBufferString(`{"enabled":true}`), + ) + req4.Header.Set("Content-Type", "application/json") + mux.ServeHTTP(rec4, req4) + if rec4.Code != http.StatusOK { + t.Fatalf("serial status = %d, want %d, body=%s", rec4.Code, http.StatusOK, rec4.Body.String()) + } + + updated, err = config.LoadConfig(configPath) + if err != nil { + t.Fatalf("LoadConfig(updated serial) error = %v", err) + } + if !updated.Tools.Serial.Enabled { + t.Fatalf("serial should be enabled: %#v", updated.Tools.Serial) + } } func TestHandleListTools_ReportsWebSearchEnabledWhenToolIsOn(t *testing.T) { diff --git a/web/frontend/src/i18n/locales/en.json b/web/frontend/src/i18n/locales/en.json index a30dc0471..50b3ad089 100644 --- a/web/frontend/src/i18n/locales/en.json +++ b/web/frontend/src/i18n/locales/en.json @@ -593,6 +593,7 @@ }, "reasons": { "requires_linux": "This tool only works on Linux hosts with the required device files exposed.", + "requires_serial_platform": "This tool currently supports Linux, macOS, and Windows hosts with accessible serial ports.", "requires_skills": "Enable `tools.skills` before this skill-registry tool can be used.", "requires_subagent": "Enable `tools.subagent` before the spawn tool can delegate work.", "requires_mcp_discovery": "Enable `tools.mcp.discovery` before MCP discovery tools become available.", diff --git a/web/frontend/src/i18n/locales/zh.json b/web/frontend/src/i18n/locales/zh.json index efe3dc32a..47f0eda21 100644 --- a/web/frontend/src/i18n/locales/zh.json +++ b/web/frontend/src/i18n/locales/zh.json @@ -593,6 +593,7 @@ }, "reasons": { "requires_linux": "该工具仅在 Linux 主机上可用，并且需要暴露对应的设备文件。", + "requires_serial_platform": "该工具当前支持 Linux、macOS 和 Windows，且要求主机可访问对应串口。", "requires_skills": "需要先启用 `tools.skills`，该技能注册表工具才能使用。", "requires_subagent": "需要先启用 `tools.subagent`，`spawn` 才能委派任务。", "requires_mcp_discovery": "需要先启用 `tools.mcp.discovery`，MCP 发现工具才会可用。", From 338fa258b34429c9a9770e4a095728f00dfd4af9 Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:56:47 +0800 Subject: [PATCH 51/87] hardware/serial: tighten validation and error handling --- pkg/tools/hardware/serial.go | 81 +++++++++++- pkg/tools/hardware/serial_other.go | 2 +- pkg/tools/hardware/serial_other_test.go | 18 +++ pkg/tools/hardware/serial_test.go | 168 +++++++++++++++++++++++- pkg/tools/hardware/serial_unix.go | 11 +- pkg/tools/hardware/serial_windows.go | 15 +-- 6 files changed, 263 insertions(+), 32 deletions(-) create mode 100644 pkg/tools/hardware/serial_other_test.go diff --git a/pkg/tools/hardware/serial.go b/pkg/tools/hardware/serial.go index 3f55da362..17f15ca94 100644 --- a/pkg/tools/hardware/serial.go +++ b/pkg/tools/hardware/serial.go @@ -4,6 +4,9 @@ import ( "context" "encoding/json" "fmt" + "math" + "regexp" + "runtime" "strings" "time" "unicode/utf8" @@ -18,6 +21,15 @@ const ( maxSerialReadBytes = 4096 ) +var ( + unixSerialPortPattern = regexp.MustCompile(`^(?:/dev/)?(?:ttyS\d+|ttyUSB\d+|ttyACM\d+|ttyAMA\d+|rfcomm\d+|tty\.[A-Za-z0-9._-]+|cu\.[A-Za-z0-9._-]+)$`) + windowsSerialPortPattern = regexp.MustCompile(`^(?:\\\\\.\\)?COM[1-9]\d*$`) + unixSerialBaudRates = map[int]struct{}{ + 50: {}, 75: {}, 110: {}, 134: {}, 150: {}, 200: {}, 300: {}, 600: {}, 1200: {}, 1800: {}, + 2400: {}, 4800: {}, 9600: {}, 19200: {}, 38400: {}, 57600: {}, 115200: {}, 230400: {}, + } +) + type SerialTool struct{} type serialPortInfo struct { @@ -60,7 +72,7 @@ func (t *SerialTool) Parameters() map[string]any { }, "baud": map[string]any{ "type": "integer", - "description": "Baud rate. Default: 115200.", + "description": "Baud rate. Default: 115200. Linux/macOS currently support standard termios rates up to 230400; Windows accepts configured rates up to 4000000.", }, "data_bits": map[string]any{ "type": "integer", @@ -209,8 +221,13 @@ func parseSerialConfig(args map[string]any) (serialConfig, *ToolResult) { return serialConfig{}, ErrorResult("port is required (for example /dev/ttyUSB0, /dev/cu.usbserial-0001, or COM3)") } + normalizedPort, err := normalizeSerialPort(port) + if err != nil { + return serialConfig{}, ErrorResult(err.Error()) + } + cfg := serialConfig{ - Port: port, + Port: normalizedPort, Baud: defaultSerialBaud, DataBits: defaultSerialDataBits, Parity: "none", @@ -220,8 +237,8 @@ func parseSerialConfig(args map[string]any) (serialConfig, *ToolResult) { if v, ok := args["baud"].(float64); ok { cfg.Baud = int(v) } - if cfg.Baud < 50 || cfg.Baud > 4000000 { - return serialConfig{}, ErrorResult("baud must be between 50 and 4000000") + if err := validateSerialBaud(cfg.Baud); err != nil { + return serialConfig{}, ErrorResult(err.Error()) } if v, ok := args["data_bits"].(float64); ok { @@ -288,6 +305,9 @@ func parseSerialWritePayload(args map[string]any) ([]byte, *ToolResult) { if !ok { return nil, ErrorResult(fmt.Sprintf("data[%d] is not a valid byte value", i)) } + if f != math.Trunc(f) { + return nil, ErrorResult(fmt.Sprintf("data[%d] is not an integer byte value", i)) + } b := int(f) if b < 0 || b > 255 { return nil, ErrorResult(fmt.Sprintf("data[%d] = %d is out of byte range (0-255)", i, b)) @@ -330,3 +350,56 @@ func serialPayloadSummary(data []byte) map[string]any { } return summary } + +func normalizeSerialPort(port string) (string, error) { + switch runtime.GOOS { + case "windows": + return normalizeWindowsSerialPath(port) + case "linux", "darwin": + return normalizeUnixSerialPath(port) + default: + if normalized, err := normalizeUnixSerialPath(port); err == nil { + return normalized, nil + } + return normalizeWindowsSerialPath(port) + } +} + +func normalizeUnixSerialPath(port string) (string, error) { + trimmed := strings.TrimSpace(port) + if !unixSerialPortPattern.MatchString(trimmed) { + return "", fmt.Errorf( + "invalid serial port: expected a safe Unix device name such as /dev/ttyUSB0 or /dev/cu.usbserial-0001", + ) + } + if strings.HasPrefix(trimmed, "/dev/") { + return trimmed, nil + } + return "/dev/" + trimmed, nil +} + +func normalizeWindowsSerialPath(port string) (string, error) { + trimmed := strings.ToUpper(strings.TrimSpace(port)) + if !windowsSerialPortPattern.MatchString(trimmed) { + return "", fmt.Errorf("invalid serial port: expected a COM port such as COM3") + } + if strings.HasPrefix(trimmed, `\\.\`) { + return trimmed, nil + } + return `\\.\` + trimmed, nil +} + +func validateSerialBaud(baud int) error { + if baud < 50 || baud > 4000000 { + return fmt.Errorf("baud must be between 50 and 4000000") + } + + switch runtime.GOOS { + case "linux", "darwin": + if _, ok := unixSerialBaudRates[baud]; !ok { + return fmt.Errorf("unsupported baud rate on this platform: %d (supported up to 230400)", baud) + } + } + + return nil +} diff --git a/pkg/tools/hardware/serial_other.go b/pkg/tools/hardware/serial_other.go index f57ce2fa3..c0f8573ee 100644 --- a/pkg/tools/hardware/serial_other.go +++ b/pkg/tools/hardware/serial_other.go @@ -8,7 +8,7 @@ import ( ) func serialListPorts() ([]serialPortInfo, error) { - return nil, nil + return nil, fmt.Errorf("serial is not supported on this platform") } func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { diff --git a/pkg/tools/hardware/serial_other_test.go b/pkg/tools/hardware/serial_other_test.go new file mode 100644 index 000000000..ef04c4062 --- /dev/null +++ b/pkg/tools/hardware/serial_other_test.go @@ -0,0 +1,18 @@ +//go:build !linux && !darwin && !windows + +package hardwaretools + +import ( + "strings" + "testing" +) + +func TestSerialListPortsUnsupportedPlatform(t *testing.T) { + _, err := serialListPorts() + if err == nil { + t.Fatal("expected unsupported platform error") + } + if !strings.Contains(err.Error(), "not supported") { + t.Fatalf("serialListPorts() error = %v, want unsupported platform message", err) + } +} diff --git a/pkg/tools/hardware/serial_test.go b/pkg/tools/hardware/serial_test.go index 68657dffd..a9e1de6b0 100644 --- a/pkg/tools/hardware/serial_test.go +++ b/pkg/tools/hardware/serial_test.go @@ -1,13 +1,20 @@ package hardwaretools import ( + "runtime" + "strings" "testing" "time" ) func TestParseSerialConfig(t *testing.T) { + port := "/dev/ttyUSB0" + if runtime.GOOS == "windows" { + port = "COM3" + } + cfg, errResult := parseSerialConfig(map[string]any{ - "port": "COM3", + "port": port, "baud": float64(9600), "data_bits": float64(7), "parity": "even", @@ -17,14 +24,23 @@ func TestParseSerialConfig(t *testing.T) { t.Fatalf("parseSerialConfig() unexpected error = %v", errResult.ForLLM) } - if cfg.Port != "COM3" || cfg.Baud != 9600 || cfg.DataBits != 7 || cfg.Parity != "even" || cfg.StopBits != 2 { + wantPort := "/dev/ttyUSB0" + if runtime.GOOS == "windows" { + wantPort = `\\.\COM3` + } + if cfg.Port != wantPort || cfg.Baud != 9600 || cfg.DataBits != 7 || cfg.Parity != "even" || cfg.StopBits != 2 { t.Fatalf("parseSerialConfig() = %#v", cfg) } } func TestParseSerialConfigRejectsInvalidParity(t *testing.T) { + port := "/dev/ttyUSB0" + if runtime.GOOS == "windows" { + port = "COM3" + } + _, errResult := parseSerialConfig(map[string]any{ - "port": "/dev/ttyUSB0", + "port": port, "parity": "mark", }) if errResult == nil { @@ -32,6 +48,152 @@ func TestParseSerialConfigRejectsInvalidParity(t *testing.T) { } } +func TestParseSerialConfigRejectsUnsupportedUnixBaud(t *testing.T) { + if runtime.GOOS != "linux" && runtime.GOOS != "darwin" { + t.Skip("Unix baud validation only applies on Unix platforms") + } + + _, errResult := parseSerialConfig(map[string]any{ + "port": "/dev/ttyUSB0", + "baud": float64(460800), + }) + if errResult == nil { + t.Fatal("expected unsupported Unix baud rate to fail") + } +} + +func TestParseSerialWritePayloadRejectsFractionalBytes(t *testing.T) { + _, errResult := parseSerialWritePayload(map[string]any{ + "data": []any{65.9}, + }) + if errResult == nil { + t.Fatal("expected fractional byte value to fail") + } +} + +func TestValidateSerialBaud(t *testing.T) { + tests := []struct { + name string + baud int + wantErr bool + }{ + {name: "default-supported", baud: 115200}, + {name: "max-unix-supported", baud: 230400}, + {name: "too-low", baud: 49, wantErr: true}, + {name: "too-high", baud: 4000001, wantErr: true}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := validateSerialBaud(tt.baud) + if (err != nil) != tt.wantErr { + t.Fatalf("validateSerialBaud(%d) error = %v, wantErr %v", tt.baud, err, tt.wantErr) + } + }) + } +} + +func TestParseSerialConfigRejectsUnsafePortPaths(t *testing.T) { + tests := []string{ + "../../../etc/passwd", + "/etc/passwd", + `C:\temp\device.txt`, + `\\.\C:\temp\device.txt`, + } + + for _, port := range tests { + t.Run(strings.ReplaceAll(port, "/", "_"), func(t *testing.T) { + _, errResult := parseSerialConfig(map[string]any{ + "port": port, + }) + if errResult == nil { + t.Fatalf("expected unsafe port %q to be rejected", port) + } + }) + } +} + +func TestNormalizeUnixSerialPath(t *testing.T) { + tests := []struct { + port string + want string + }{ + {port: "ttyUSB0", want: "/dev/ttyUSB0"}, + {port: "/dev/ttyACM0", want: "/dev/ttyACM0"}, + {port: "/dev/cu.usbserial-0001", want: "/dev/cu.usbserial-0001"}, + } + + for _, tt := range tests { + got, err := normalizeUnixSerialPath(tt.port) + if err != nil { + t.Fatalf("normalizeUnixSerialPath(%q) unexpected error = %v", tt.port, err) + } + if got != tt.want { + t.Fatalf("normalizeUnixSerialPath(%q) = %q, want %q", tt.port, got, tt.want) + } + } +} + +func TestNormalizeUnixSerialPathRejectsInvalidNames(t *testing.T) { + tests := []string{ + "", + "ttyUSB0/../../passwd", + "/dev/../../etc/passwd", + "/tmp/ttyUSB0", + "ttyUSB", + "COM3", + } + + for _, port := range tests { + t.Run(strings.ReplaceAll(port, "/", "_"), func(t *testing.T) { + if _, err := normalizeUnixSerialPath(port); err == nil { + t.Fatalf("expected %q to be rejected", port) + } + }) + } +} + +func TestNormalizeWindowsSerialPath(t *testing.T) { + tests := []struct { + port string + want string + }{ + {port: "COM3", want: `\\.\COM3`}, + {port: "com12", want: `\\.\COM12`}, + {port: `\\.\COM7`, want: `\\.\COM7`}, + } + + for _, tt := range tests { + got, err := normalizeWindowsSerialPath(tt.port) + if err != nil { + t.Fatalf("normalizeWindowsSerialPath(%q) unexpected error = %v", tt.port, err) + } + if got != tt.want { + t.Fatalf("normalizeWindowsSerialPath(%q) = %q, want %q", tt.port, got, tt.want) + } + } +} + +func TestNormalizeWindowsSerialPathRejectsInvalidNames(t *testing.T) { + tests := []string{ + "", + "COM0", + "COM", + "/dev/ttyUSB0", + `C:\temp\device.txt`, + `\\.\C:\temp\device.txt`, + `\\server\share\COM3`, + } + + for _, port := range tests { + t.Run(strings.ReplaceAll(strings.ReplaceAll(port, `\`, "_"), "/", "_"), func(t *testing.T) { + if _, err := normalizeWindowsSerialPath(port); err == nil { + t.Fatalf("expected %q to be rejected", port) + } + }) + } +} + func TestParseSerialTimeout(t *testing.T) { timeout, errResult := parseSerialTimeout(map[string]any{ "timeout_ms": float64(2500), diff --git a/pkg/tools/hardware/serial_unix.go b/pkg/tools/hardware/serial_unix.go index caef7e0e8..d5094b208 100644 --- a/pkg/tools/hardware/serial_unix.go +++ b/pkg/tools/hardware/serial_unix.go @@ -7,7 +7,6 @@ import ( "os" "path/filepath" "sort" - "strings" "time" "golang.org/x/sys/unix" @@ -112,7 +111,7 @@ func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, err } func openAndConfigureSerialPort(cfg serialConfig) (int, error) { - fd, err := unix.Open(normalizeUnixSerialPath(cfg.Port), unix.O_RDWR|unix.O_NOCTTY|unix.O_NONBLOCK, 0) + fd, err := unix.Open(cfg.Port, unix.O_RDWR|unix.O_NOCTTY|unix.O_NONBLOCK, 0) if err != nil { return -1, err } @@ -253,11 +252,3 @@ func durationToPollTimeout(timeout time.Duration) int { } return ms } - -func normalizeUnixSerialPath(port string) string { - trimmed := strings.TrimSpace(port) - if strings.HasPrefix(trimmed, "/dev/") { - return trimmed - } - return "/dev/" + trimmed -} diff --git a/pkg/tools/hardware/serial_windows.go b/pkg/tools/hardware/serial_windows.go index c4d119ac4..a109b8025 100644 --- a/pkg/tools/hardware/serial_windows.go +++ b/pkg/tools/hardware/serial_windows.go @@ -4,7 +4,6 @@ package hardwaretools import ( "fmt" - "path/filepath" "sort" "strings" "time" @@ -126,9 +125,8 @@ func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, err } func openAndConfigureWindowsSerial(cfg serialConfig, timeout time.Duration) (windows.Handle, error) { - path := normalizeWindowsSerialPath(cfg.Port) handle, err := windows.CreateFile( - windows.StringToUTF16Ptr(path), + windows.StringToUTF16Ptr(cfg.Port), windows.GENERIC_READ|windows.GENERIC_WRITE, 0, nil, @@ -201,14 +199,3 @@ func configureWindowsSerialPort(handle windows.Handle, cfg serialConfig, timeout procPurgeComm.Call(uintptr(handle), uintptr(purgeRxClear|purgeTxClear)) return nil } - -func normalizeWindowsSerialPath(port string) string { - trimmed := strings.ToUpper(strings.TrimSpace(port)) - if strings.HasPrefix(trimmed, `\\.\`) { - return trimmed - } - if filepath.VolumeName(trimmed) != "" { - return trimmed - } - return `\\.\` + trimmed -} From 1f0a5f4eda88524bde40cc39612035376b1d8630 Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:57:09 +0800 Subject: [PATCH 52/87] hardware/serial: improve unix cancellation and timeout polling --- pkg/tools/hardware/serial.go | 22 ++-- pkg/tools/hardware/serial_other.go | 5 +- pkg/tools/hardware/serial_test.go | 36 +++++++ pkg/tools/hardware/serial_unix.go | 60 ++++++++--- pkg/tools/hardware/serial_unix_test.go | 140 +++++++++++++++++++++++++ pkg/tools/hardware/serial_windows.go | 21 +++- 6 files changed, 260 insertions(+), 24 deletions(-) create mode 100644 pkg/tools/hardware/serial_unix_test.go diff --git a/pkg/tools/hardware/serial.go b/pkg/tools/hardware/serial.go index 17f15ca94..3a2ead824 100644 --- a/pkg/tools/hardware/serial.go +++ b/pkg/tools/hardware/serial.go @@ -19,6 +19,7 @@ const ( defaultSerialTimeoutMS = 1000 maxSerialPayloadBytes = 4096 maxSerialReadBytes = 4096 + serialPollInterval = 100 * time.Millisecond ) var ( @@ -123,9 +124,9 @@ func (t *SerialTool) Execute(ctx context.Context, args map[string]any) *ToolResu case "list": return t.list() case "read": - return t.read(args) + return t.read(ctx, args) case "write": - return t.write(args) + return t.write(ctx, args) default: return ErrorResult(fmt.Sprintf("unknown action: %s (valid: list, read, write)", action)) } @@ -147,7 +148,7 @@ func (t *SerialTool) list() *ToolResult { return SilentResult(string(result)) } -func (t *SerialTool) read(args map[string]any) *ToolResult { +func (t *SerialTool) read(ctx context.Context, args map[string]any) *ToolResult { cfg, errResult := parseSerialConfig(args) if errResult != nil { return errResult @@ -166,7 +167,7 @@ func (t *SerialTool) read(args map[string]any) *ToolResult { return errResult } - data, err := serialRead(cfg, length, timeout) + data, err := serialRead(ctx, cfg, length, timeout) if err != nil { return ErrorResult(fmt.Sprintf("serial read failed on %s: %v", cfg.Port, err)) } @@ -174,7 +175,7 @@ func (t *SerialTool) read(args map[string]any) *ToolResult { return SilentResult(formatSerialPayload("read", cfg, data, timeout)) } -func (t *SerialTool) write(args map[string]any) *ToolResult { +func (t *SerialTool) write(ctx context.Context, args map[string]any) *ToolResult { confirm, _ := args["confirm"].(bool) if !confirm { return ErrorResult( @@ -195,7 +196,7 @@ func (t *SerialTool) write(args map[string]any) *ToolResult { return errResult } - written, err := serialWrite(cfg, payload, timeout) + written, err := serialWrite(ctx, cfg, payload, timeout) if err != nil { return ErrorResult(fmt.Sprintf("serial write failed on %s: %v", cfg.Port, err)) } @@ -403,3 +404,12 @@ func validateSerialBaud(baud int) error { return nil } + +func serialContextErr(ctx context.Context) error { + select { + case <-ctx.Done(): + return ctx.Err() + default: + return nil + } +} diff --git a/pkg/tools/hardware/serial_other.go b/pkg/tools/hardware/serial_other.go index c0f8573ee..ec72a2d2a 100644 --- a/pkg/tools/hardware/serial_other.go +++ b/pkg/tools/hardware/serial_other.go @@ -3,6 +3,7 @@ package hardwaretools import ( + "context" "fmt" "time" ) @@ -11,10 +12,10 @@ func serialListPorts() ([]serialPortInfo, error) { return nil, fmt.Errorf("serial is not supported on this platform") } -func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { +func serialRead(ctx context.Context, cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { return nil, fmt.Errorf("serial is not supported on this platform") } -func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, error) { +func serialWrite(ctx context.Context, cfg serialConfig, data []byte, timeout time.Duration) (int, error) { return 0, fmt.Errorf("serial is not supported on this platform") } diff --git a/pkg/tools/hardware/serial_test.go b/pkg/tools/hardware/serial_test.go index a9e1de6b0..5f9e2a44d 100644 --- a/pkg/tools/hardware/serial_test.go +++ b/pkg/tools/hardware/serial_test.go @@ -1,6 +1,7 @@ package hardwaretools import ( + "context" "runtime" "strings" "testing" @@ -93,6 +94,41 @@ func TestValidateSerialBaud(t *testing.T) { } } +func TestSerialReadCanceledBeforeOpen(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + + port := "/dev/ttyUSB0" + if runtime.GOOS == "windows" { + port = "COM3" + } + + _, err := serialRead(ctx, serialConfig{Port: port, Baud: 115200, DataBits: 8, Parity: "none", StopBits: 1}, 1, time.Second) + if err == nil || !strings.Contains(err.Error(), context.Canceled.Error()) { + t.Fatalf("serialRead() error = %v, want context canceled", err) + } +} + +func TestSerialWriteCanceledBeforeOpen(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + + port := "/dev/ttyUSB0" + if runtime.GOOS == "windows" { + port = "COM3" + } + + _, err := serialWrite( + ctx, + serialConfig{Port: port, Baud: 115200, DataBits: 8, Parity: "none", StopBits: 1}, + []byte("AT"), + time.Second, + ) + if err == nil || !strings.Contains(err.Error(), context.Canceled.Error()) { + t.Fatalf("serialWrite() error = %v, want context canceled", err) + } +} + func TestParseSerialConfigRejectsUnsafePortPaths(t *testing.T) { tests := []string{ "../../../etc/passwd", diff --git a/pkg/tools/hardware/serial_unix.go b/pkg/tools/hardware/serial_unix.go index d5094b208..548b8573b 100644 --- a/pkg/tools/hardware/serial_unix.go +++ b/pkg/tools/hardware/serial_unix.go @@ -3,6 +3,7 @@ package hardwaretools import ( + "context" "fmt" "os" "path/filepath" @@ -12,6 +13,14 @@ import ( "golang.org/x/sys/unix" ) +var ( + unixSerialNow = time.Now + unixSerialOpenPort = openAndConfigureSerialPort + unixSerialClosePort = unix.Close + unixSerialPollRead = pollRead + unixSerialPollWrite = pollWrite +) + func serialListPorts() ([]serialPortInfo, error) { patterns := []string{ "/dev/ttyS*", @@ -52,29 +61,37 @@ func serialListPorts() ([]serialPortInfo, error) { return ports, nil } -func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { - fd, err := openAndConfigureSerialPort(cfg) +func serialRead(ctx context.Context, cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { + if err := serialContextErr(ctx); err != nil { + return nil, err + } + + fd, err := unixSerialOpenPort(cfg) if err != nil { return nil, err } - defer unix.Close(fd) + defer unixSerialClosePort(fd) buf := make([]byte, length) total := 0 - deadline := time.Now().Add(timeout) + deadline := unixSerialNow().Add(timeout) for total < length { - remaining := time.Until(deadline) + if err := serialContextErr(ctx); err != nil { + return nil, err + } + + remaining := deadline.Sub(unixSerialNow()) if remaining <= 0 { break } - n, err := pollRead(fd, buf[total:], remaining) + n, err := unixSerialPollRead(fd, buf[total:], minSerialPollTimeout(remaining)) if err != nil { return nil, err } if n == 0 { - break + continue } total += n } @@ -82,27 +99,35 @@ func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, er return buf[:total], nil } -func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, error) { - fd, err := openAndConfigureSerialPort(cfg) +func serialWrite(ctx context.Context, cfg serialConfig, data []byte, timeout time.Duration) (int, error) { + if err := serialContextErr(ctx); err != nil { + return 0, err + } + + fd, err := unixSerialOpenPort(cfg) if err != nil { return 0, err } - defer unix.Close(fd) + defer unixSerialClosePort(fd) total := 0 - deadline := time.Now().Add(timeout) + deadline := unixSerialNow().Add(timeout) for total < len(data) { - remaining := time.Until(deadline) + if err := serialContextErr(ctx); err != nil { + return total, err + } + + remaining := deadline.Sub(unixSerialNow()) if remaining <= 0 { return total, fmt.Errorf("timeout while writing serial data") } - n, err := pollWrite(fd, data[total:], remaining) + n, err := unixSerialPollWrite(fd, data[total:], minSerialPollTimeout(remaining)) if err != nil { return total, err } if n == 0 { - return total, fmt.Errorf("serial port accepted zero bytes") + continue } total += n } @@ -252,3 +277,10 @@ func durationToPollTimeout(timeout time.Duration) int { } return ms } + +func minSerialPollTimeout(timeout time.Duration) time.Duration { + if timeout > serialPollInterval { + return serialPollInterval + } + return timeout +} diff --git a/pkg/tools/hardware/serial_unix_test.go b/pkg/tools/hardware/serial_unix_test.go new file mode 100644 index 000000000..fac2efe7f --- /dev/null +++ b/pkg/tools/hardware/serial_unix_test.go @@ -0,0 +1,140 @@ +//go:build linux || darwin + +package hardwaretools + +import ( + "context" + "errors" + "testing" + "time" +) + +func stubUnixSerialIO(t *testing.T, now *time.Time) { + t.Helper() + + prevNow := unixSerialNow + prevOpen := unixSerialOpenPort + prevClose := unixSerialClosePort + prevPollRead := unixSerialPollRead + prevPollWrite := unixSerialPollWrite + + unixSerialNow = func() time.Time { + return *now + } + unixSerialOpenPort = func(cfg serialConfig) (int, error) { + return 42, nil + } + unixSerialClosePort = func(fd int) error { + return nil + } + unixSerialPollRead = prevPollRead + unixSerialPollWrite = prevPollWrite + + t.Cleanup(func() { + unixSerialNow = prevNow + unixSerialOpenPort = prevOpen + unixSerialClosePort = prevClose + unixSerialPollRead = prevPollRead + unixSerialPollWrite = prevPollWrite + }) +} + +func TestSerialReadWaitsPastEmptyPollsUntilDeadline(t *testing.T) { + now := time.Unix(0, 0) + stubUnixSerialIO(t, &now) + + pollCalls := 0 + unixSerialPollRead = func(fd int, dst []byte, timeout time.Duration) (int, error) { + pollCalls++ + if timeout > serialPollInterval { + t.Fatalf("poll timeout = %v, want <= %v", timeout, serialPollInterval) + } + now = now.Add(timeout) + if pollCalls < 4 { + return 0, nil + } + return copy(dst, []byte("OK")), nil + } + + got, err := serialRead(context.Background(), serialConfig{}, 2, 500*time.Millisecond) + if err != nil { + t.Fatalf("serialRead() error = %v", err) + } + if string(got) != "OK" { + t.Fatalf("serialRead() = %q, want %q", got, "OK") + } + if pollCalls != 4 { + t.Fatalf("poll calls = %d, want 4", pollCalls) + } +} + +func TestSerialReadReturnsPromptlyOnContextCancelBetweenPolls(t *testing.T) { + now := time.Unix(0, 0) + stubUnixSerialIO(t, &now) + + ctx, cancel := context.WithCancel(context.Background()) + pollCalls := 0 + unixSerialPollRead = func(fd int, dst []byte, timeout time.Duration) (int, error) { + pollCalls++ + now = now.Add(timeout) + cancel() + return 0, nil + } + + _, err := serialRead(ctx, serialConfig{}, 1, time.Second) + if !errors.Is(err, context.Canceled) { + t.Fatalf("serialRead() error = %v, want context canceled", err) + } + if pollCalls != 1 { + t.Fatalf("poll calls = %d, want 1", pollCalls) + } +} + +func TestSerialWriteWaitsPastEmptyPollsUntilReady(t *testing.T) { + now := time.Unix(0, 0) + stubUnixSerialIO(t, &now) + + pollCalls := 0 + unixSerialPollWrite = func(fd int, src []byte, timeout time.Duration) (int, error) { + pollCalls++ + if timeout > serialPollInterval { + t.Fatalf("poll timeout = %v, want <= %v", timeout, serialPollInterval) + } + now = now.Add(timeout) + switch pollCalls { + case 1, 2: + return 0, nil + default: + return 1, nil + } + } + + written, err := serialWrite(context.Background(), serialConfig{}, []byte("OK"), 500*time.Millisecond) + if err != nil { + t.Fatalf("serialWrite() error = %v", err) + } + if written != 2 { + t.Fatalf("serialWrite() wrote %d bytes, want 2", written) + } + if pollCalls != 4 { + t.Fatalf("poll calls = %d, want 4", pollCalls) + } +} + +func TestSerialWriteTimesOutAfterRepeatedEmptyPolls(t *testing.T) { + now := time.Unix(0, 0) + stubUnixSerialIO(t, &now) + + unixSerialPollWrite = func(fd int, src []byte, timeout time.Duration) (int, error) { + now = now.Add(timeout) + return 0, nil + } + + written, err := serialWrite(context.Background(), serialConfig{}, []byte("A"), 250*time.Millisecond) + if err == nil || err.Error() != "timeout while writing serial data" { + t.Fatalf("serialWrite() error = %v, want timeout", err) + } + if written != 0 { + t.Fatalf("serialWrite() wrote %d bytes, want 0", written) + } +} diff --git a/pkg/tools/hardware/serial_windows.go b/pkg/tools/hardware/serial_windows.go index a109b8025..1dcbfa7a9 100644 --- a/pkg/tools/hardware/serial_windows.go +++ b/pkg/tools/hardware/serial_windows.go @@ -3,6 +3,7 @@ package hardwaretools import ( + "context" "fmt" "sort" "strings" @@ -95,13 +96,21 @@ func serialListPorts() ([]serialPortInfo, error) { return ports, nil } -func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { +func serialRead(ctx context.Context, cfg serialConfig, length int, timeout time.Duration) ([]byte, error) { + if err := serialContextErr(ctx); err != nil { + return nil, err + } + handle, err := openAndConfigureWindowsSerial(cfg, timeout) if err != nil { return nil, err } defer windows.CloseHandle(handle) + if err := serialContextErr(ctx); err != nil { + return nil, err + } + buf := make([]byte, length) var read uint32 if err := windows.ReadFile(handle, buf, &read, nil); err != nil { @@ -110,13 +119,21 @@ func serialRead(cfg serialConfig, length int, timeout time.Duration) ([]byte, er return buf[:read], nil } -func serialWrite(cfg serialConfig, data []byte, timeout time.Duration) (int, error) { +func serialWrite(ctx context.Context, cfg serialConfig, data []byte, timeout time.Duration) (int, error) { + if err := serialContextErr(ctx); err != nil { + return 0, err + } + handle, err := openAndConfigureWindowsSerial(cfg, timeout) if err != nil { return 0, err } defer windows.CloseHandle(handle) + if err := serialContextErr(ctx); err != nil { + return 0, err + } + var written uint32 if err := windows.WriteFile(handle, data, &written, nil); err != nil { return int(written), err From 64e48163d043ecdc1bd90eaff6632fb3a68fdf67 Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:57:25 +0800 Subject: [PATCH 53/87] hardware/serial: improve windows I/O handling --- pkg/tools/hardware/serial.go | 34 ++++++++ pkg/tools/hardware/serial_windows.go | 48 ++++++++-- pkg/tools/hardware/serial_windows_test.go | 39 +++++++++ .../hardware/serial_write_common_test.go | 87 +++++++++++++++++++ 4 files changed, 199 insertions(+), 9 deletions(-) create mode 100644 pkg/tools/hardware/serial_windows_test.go create mode 100644 pkg/tools/hardware/serial_write_common_test.go diff --git a/pkg/tools/hardware/serial.go b/pkg/tools/hardware/serial.go index 3a2ead824..52e47fc7a 100644 --- a/pkg/tools/hardware/serial.go +++ b/pkg/tools/hardware/serial.go @@ -413,3 +413,37 @@ func serialContextErr(ctx context.Context) error { return nil } } + +func serialWriteAll( + ctx context.Context, + data []byte, + timeout time.Duration, + now func() time.Time, + write func([]byte) (int, error), +) (int, error) { + if err := serialContextErr(ctx); err != nil { + return 0, err + } + + total := 0 + deadline := now().Add(timeout) + for total < len(data) { + if err := serialContextErr(ctx); err != nil { + return total, err + } + if deadline.Sub(now()) <= 0 { + return total, fmt.Errorf("timeout while writing serial data") + } + + n, err := write(data[total:]) + total += n + if err != nil { + return total, err + } + if n == 0 { + continue + } + } + + return total, nil +} diff --git a/pkg/tools/hardware/serial_windows.go b/pkg/tools/hardware/serial_windows.go index 1dcbfa7a9..36f8b4271 100644 --- a/pkg/tools/hardware/serial_windows.go +++ b/pkg/tools/hardware/serial_windows.go @@ -25,6 +25,17 @@ var ( const ( purgeTxClear = 0x0004 purgeRxClear = 0x0008 + + dcbFlagBinary = 0x00000001 + dcbFlagParity = 0x00000002 + dcbFlagOutxCtsFlow = 0x00000004 + dcbFlagOutxDsrFlow = 0x00000008 + dcbFlagDtrControlMask = 0x00000030 + dcbFlagDsrSensitivity = 0x00000040 + dcbFlagTXContinueOnXoff = 0x00000080 + dcbFlagOutX = 0x00000100 + dcbFlagInX = 0x00000200 + dcbFlagRtsControlMask = 0x00003000 ) type dcb struct { @@ -113,6 +124,8 @@ func serialRead(ctx context.Context, cfg serialConfig, length int, timeout time. buf := make([]byte, length) var read uint32 + // Synchronous serial I/O on Windows cannot be interrupted once the syscall starts. + // COMMTIMEOUTS bounds how long turn cancellation may take to surface. if err := windows.ReadFile(handle, buf, &read, nil); err != nil { return nil, err } @@ -134,11 +147,15 @@ func serialWrite(ctx context.Context, cfg serialConfig, data []byte, timeout tim return 0, err } - var written uint32 - if err := windows.WriteFile(handle, data, &written, nil); err != nil { - return int(written), err - } - return int(written), nil + return serialWriteAll(ctx, data, timeout, time.Now, func(chunk []byte) (int, error) { + var written uint32 + // Like ReadFile above, this synchronous WriteFile call relies on COMMTIMEOUTS + // rather than context preemption once the syscall is in flight. + if err := windows.WriteFile(handle, chunk, &written, nil); err != nil { + return int(written), err + } + return int(written), nil + }) } func openAndConfigureWindowsSerial(cfg serialConfig, timeout time.Duration) (windows.Handle, error) { @@ -171,18 +188,19 @@ func configureWindowsSerialPort(handle windows.Handle, cfg serialConfig, timeout state.BaudRate = uint32(cfg.Baud) state.ByteSize = byte(cfg.DataBits) - state.Flags |= 0x00000001 // fBinary + state.Flags = sanitizeWindowsSerialFlags(state.Flags) + state.Flags |= dcbFlagBinary switch cfg.Parity { case "even": state.Parity = 2 - state.Flags |= 0x00000002 // fParity + state.Flags |= dcbFlagParity case "odd": state.Parity = 1 - state.Flags |= 0x00000002 // fParity + state.Flags |= dcbFlagParity default: state.Parity = 0 - state.Flags &^= 0x00000002 + state.Flags &^= dcbFlagParity } switch cfg.StopBits { @@ -216,3 +234,15 @@ func configureWindowsSerialPort(handle windows.Handle, cfg serialConfig, timeout procPurgeComm.Call(uintptr(handle), uintptr(purgeRxClear|purgeTxClear)) return nil } + +func sanitizeWindowsSerialFlags(flags uint32) uint32 { + flags &^= dcbFlagOutxCtsFlow | + dcbFlagOutxDsrFlow | + dcbFlagDtrControlMask | + dcbFlagDsrSensitivity | + dcbFlagTXContinueOnXoff | + dcbFlagOutX | + dcbFlagInX | + dcbFlagRtsControlMask + return flags +} diff --git a/pkg/tools/hardware/serial_windows_test.go b/pkg/tools/hardware/serial_windows_test.go new file mode 100644 index 000000000..ecb0addbd --- /dev/null +++ b/pkg/tools/hardware/serial_windows_test.go @@ -0,0 +1,39 @@ +//go:build windows + +package hardwaretools + +import "testing" + +func TestSanitizeWindowsSerialFlags(t *testing.T) { + flags := uint32( + dcbFlagBinary | + dcbFlagParity | + dcbFlagOutxCtsFlow | + dcbFlagOutxDsrFlow | + dcbFlagDtrControlMask | + dcbFlagDsrSensitivity | + dcbFlagTXContinueOnXoff | + dcbFlagOutX | + dcbFlagInX | + dcbFlagRtsControlMask, + ) + + got := sanitizeWindowsSerialFlags(flags) + + if got&dcbFlagBinary == 0 { + t.Fatal("sanitizeWindowsSerialFlags() should preserve fBinary") + } + if got&dcbFlagParity == 0 { + t.Fatal("sanitizeWindowsSerialFlags() should preserve fParity") + } + if got&(dcbFlagOutxCtsFlow| + dcbFlagOutxDsrFlow| + dcbFlagDtrControlMask| + dcbFlagDsrSensitivity| + dcbFlagTXContinueOnXoff| + dcbFlagOutX| + dcbFlagInX| + dcbFlagRtsControlMask) != 0 { + t.Fatalf("sanitizeWindowsSerialFlags() = %#x, want flow-control bits cleared", got) + } +} diff --git a/pkg/tools/hardware/serial_write_common_test.go b/pkg/tools/hardware/serial_write_common_test.go new file mode 100644 index 000000000..398c1fde5 --- /dev/null +++ b/pkg/tools/hardware/serial_write_common_test.go @@ -0,0 +1,87 @@ +package hardwaretools + +import ( + "context" + "errors" + "testing" + "time" +) + +func TestSerialWriteAllRetriesPartialWritesUntilComplete(t *testing.T) { + now := time.Unix(0, 0) + calls := 0 + + written, err := serialWriteAll(context.Background(), []byte("PING"), time.Second, func() time.Time { + return now + }, func(chunk []byte) (int, error) { + calls++ + now = now.Add(100 * time.Millisecond) + switch calls { + case 1: + if string(chunk) != "PING" { + t.Fatalf("first chunk = %q, want %q", chunk, "PING") + } + return 2, nil + case 2: + if string(chunk) != "NG" { + t.Fatalf("second chunk = %q, want %q", chunk, "NG") + } + return 2, nil + default: + t.Fatalf("unexpected extra write call %d", calls) + return 0, nil + } + }) + if err != nil { + t.Fatalf("serialWriteAll() error = %v", err) + } + if written != 4 { + t.Fatalf("serialWriteAll() wrote %d bytes, want 4", written) + } +} + +func TestSerialWriteAllTimesOutAfterZeroByteWrites(t *testing.T) { + now := time.Unix(0, 0) + calls := 0 + + written, err := serialWriteAll(context.Background(), []byte("A"), 250*time.Millisecond, func() time.Time { + return now + }, func(chunk []byte) (int, error) { + calls++ + now = now.Add(100 * time.Millisecond) + return 0, nil + }) + if err == nil || err.Error() != "timeout while writing serial data" { + t.Fatalf("serialWriteAll() error = %v, want timeout", err) + } + if written != 0 { + t.Fatalf("serialWriteAll() wrote %d bytes, want 0", written) + } + if calls != 3 { + t.Fatalf("write calls = %d, want 3", calls) + } +} + +func TestSerialWriteAllReturnsContextCancellationAfterRetryBoundary(t *testing.T) { + now := time.Unix(0, 0) + ctx, cancel := context.WithCancel(context.Background()) + calls := 0 + + written, err := serialWriteAll(ctx, []byte("A"), time.Second, func() time.Time { + return now + }, func(chunk []byte) (int, error) { + calls++ + now = now.Add(100 * time.Millisecond) + cancel() + return 0, nil + }) + if !errors.Is(err, context.Canceled) { + t.Fatalf("serialWriteAll() error = %v, want context canceled", err) + } + if written != 0 { + t.Fatalf("serialWriteAll() wrote %d bytes, want 0", written) + } + if calls != 1 { + t.Fatalf("write calls = %d, want 1", calls) + } +} From 893e61dc51c53c6f9630922fae9047f6478c580a Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:57:44 +0800 Subject: [PATCH 54/87] hardware/serial: fix darwin cross-compilation build --- pkg/tools/hardware/serial_darwin.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/tools/hardware/serial_darwin.go b/pkg/tools/hardware/serial_darwin.go index f6cf30db4..bc019029e 100644 --- a/pkg/tools/hardware/serial_darwin.go +++ b/pkg/tools/hardware/serial_darwin.go @@ -9,8 +9,8 @@ func serialGetTermios(fd int) (*unix.Termios, error) { } func serialSetSpeed(tio *unix.Termios, speed uint32) error { - tio.Ispeed = speed - tio.Ospeed = speed + tio.Ispeed = uint64(speed) + tio.Ospeed = uint64(speed) return nil } From 2baeee2834db58f220827e981c9991120923c421 Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:57:44 +0800 Subject: [PATCH 55/87] docs(design): summarize hardware support and serial limits --- .../current-hardware-support-and-serial.zh.md | 91 +++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 docs/design/current-hardware-support-and-serial.zh.md diff --git a/docs/design/current-hardware-support-and-serial.zh.md b/docs/design/current-hardware-support-and-serial.zh.md new file mode 100644 index 000000000..bf91355c2 --- /dev/null +++ b/docs/design/current-hardware-support-and-serial.zh.md @@ -0,0 +1,91 @@ +# 当前硬件支持现状与串口 Tool 方案 + +## 现状结论 + +当前项目已有的硬件相关能力主要分为两条线： + +1. 设备事件监控 + - `pkg/devices` 已实现设备事件服务。 + - 当前只有 Linux USB 热插拔事件源 `pkg/devices/sources/usb_linux.go`。 + - 能力定位是“发现和通知”，不是“总线读写控制”。 + +2. 硬件控制 Tool + - `pkg/tools/hardware/i2c*.go`：I2C Tool，支持 `detect`、`scan`、`read`、`write`。 + - `pkg/tools/hardware/spi*.go`：SPI Tool，支持 `list`、`transfer`、`read`。 + - 这两类 Tool 当前都只在 Linux 主机上启用，直接依赖 `/dev/i2c-*` 与 `/dev/spidev*`。 + +因此，项目在“硬件支持能力”上已经具备： + +- Linux USB 设备插拔感知 +- Linux I2C 总线控制 +- Linux SPI 总线控制 + +但还缺少： + +- 串口/UART 控制 +- macOS / Windows 下可直接使用的硬件控制 Tool +- 面向统一硬件抽象的跨总线能力模型 + +## 本次新增 + +本次新增内建 `serial` Tool，并接入现有 Tool 体系： + +- 配置项：`tools.serial.enabled` +- Tool 注册：`pkg/agent/agent_init.go` +- Web 工具页：`/api/tools` 能展示与切换 `serial` +- 前端状态文案：新增 `requires_serial_platform` + +## Serial Tool 设计 + +`serial` 采用无状态调用模型，每次请求都自行打开和关闭端口，避免在 agent 回合之间维护串口会话状态。 + +支持动作： + +- `list`：枚举主机串口 +- `read`：从串口读取指定长度字节 +- `write`：向串口写入字节或文本 + +公共参数： + +- `port` +- `baud` +- `data_bits` +- `parity` +- `stop_bits` +- `timeout_ms` + +当前波特率实现边界： + +- Windows 允许配置工具层接受的范围 `50-4000000` +- Linux / macOS 当前仅支持标准 termios 波特率，实际支持到 `230400` +- 因此 `baud` 的跨平台可移植取值应优先使用 `230400` 及以下的常见标准速率 + +安全约束： + +- `write` 必须显式传 `confirm: true` +- 单次读写负载限制为 `4096` 字节 +- `port` 只接受白名单串口名： + - Linux / macOS 仅允许 `/dev/tty*`、`/dev/cu.*` 及对应简写设备名 + - Windows 仅允许 `COM\d+` 或 `\\.\COM\d+` + - 明确拒绝 `..`、普通文件绝对路径、盘符路径等非串口设备路径，避免路径穿越或误打开任意文件 + +## 跨平台实现边界 + +- Linux / macOS： + - 基于 `golang.org/x/sys/unix` 和 termios 配置串口参数。 + - 当前仅接入标准 termios 波特率映射，最高到 `230400`，尚未扩展 `460800`、`921600`、`1000000`、`2000000` 等更高速率。 + - 通过 `/dev/...` 枚举和访问设备。 + +- Windows： + - 基于 `kernel32` 串口 API 配置 `DCB` 和 `COMMTIMEOUTS`。 + - 当前读写仍使用同步 `ReadFile` / `WriteFile`；一旦 syscall 已进入执行，turn context cancellation 不能立即打断，只能等待 `COMMTIMEOUTS` 触发后返回。 + - 通过注册表 `HARDWARE\\DEVICEMAP\\SERIALCOMM` 枚举端口。 + +- 其他平台： + - `serial` Tool 显式返回 unsupported，不做静默降级。 + +## 后续建议 + +1. 如果需要持续交互式串口会话，建议再增加 session 型 Tool，而不是让 LLM 反复做短连接轮询。 +2. 如果后续要支持 CAN、GPIO、PWM，建议抽出统一的硬件 capability 描述层，而不是继续只靠 Tool 名称区分。 +3. 若需要生产级稳定性，建议补真实串口回环测试，至少覆盖 Linux PTY 和 Windows COM 模拟场景。 From 688d47d23638a3e94041251bebb2d0b855aa9d5d Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Mon, 27 Apr 2026 17:44:26 +0800 Subject: [PATCH 56/87] build: keep go generate on host during cross builds --- Makefile | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index acb258370..0f6a036f4 100644 --- a/Makefile +++ b/Makefile @@ -171,6 +171,18 @@ ifeq ($(OS),Windows_NT) EXT=.exe endif +ifneq ($(strip $(GOOS)),) + PLATFORM:=$(GOOS) +endif + +ifneq ($(strip $(GOARCH)),) + ARCH:=$(GOARCH) +endif + +ifeq ($(PLATFORM),windows) + EXT=.exe +endif + BINARY_PATH=$(BUILD_DIR)/$(BINARY_NAME)-$(PLATFORM)-$(ARCH) # Default target @@ -181,10 +193,11 @@ generate: @echo "Run generate..." ifeq ($(OS),Windows_NT) @$(POWERSHELL) "if (Test-Path -LiteralPath './$(CMD_DIR)/workspace') { Remove-Item -LiteralPath './$(CMD_DIR)/workspace' -Recurse -Force }" + @$(POWERSHELL) "$$env:GOOS=''; $$env:GOARCH=''; $(GO) generate ./..." else @rm -r ./$(CMD_DIR)/workspace 2>/dev/null || true + @GOOS=$$($(GO) env GOHOSTOS) GOARCH=$$($(GO) env GOHOSTARCH) $(GO) generate ./... endif - @$(GO) generate ./... @echo "Run generate complete" ## build: Build the picoclaw binary for current platform @@ -196,7 +209,7 @@ ifeq ($(OS),Windows_NT) @$(POWERSHELL) "Copy-Item -LiteralPath '$(BINARY_PATH)$(EXT)' -Destination '$(BUILD_DIR)/$(BINARY_NAME)$(EXT)' -Force" else @mkdir -p $(BUILD_DIR) - @GOARCH=${ARCH} $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_PATH)$(EXT) ./$(CMD_DIR) + @GOOS=$(PLATFORM) GOARCH=$(ARCH) $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_PATH)$(EXT) ./$(CMD_DIR) @echo "Build complete: $(BINARY_PATH)$(EXT)" @$(LNCMD) $(BINARY_NAME)-$(PLATFORM)-$(ARCH)$(EXT) $(BUILD_DIR)/$(BINARY_NAME)$(EXT) endif @@ -211,7 +224,7 @@ ifeq ($(OS),Windows_NT) @$(POWERSHELL) "Copy-Item -LiteralPath '$(BUILD_DIR)/picoclaw-launcher-$(PLATFORM)-$(ARCH)$(EXT)' -Destination '$(BUILD_DIR)/picoclaw-launcher$(EXT)' -Force" else @mkdir -p $(BUILD_DIR) - @GOARCH=${ARCH} $(MAKE) -C web build \ + @GOOS=$(PLATFORM) GOARCH=$(ARCH) $(MAKE) -C web build \ OUTPUT="$(CURDIR)/$(BUILD_DIR)/picoclaw-launcher-$(PLATFORM)-$(ARCH)$(EXT)" \ WEB_GO='$(WEB_GO)' \ GO_BUILD_TAGS='$(GO_BUILD_TAGS)' \ From 29e7461837590ed17d19c7f7e80cfc56c556267b Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:58:26 +0800 Subject: [PATCH 57/87] onboard: drop unrelated go generate change from serial work --- cmd/picoclaw/internal/onboard/command.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/picoclaw/internal/onboard/command.go b/cmd/picoclaw/internal/onboard/command.go index 3f0ff0d8d..bf8f4104f 100644 --- a/cmd/picoclaw/internal/onboard/command.go +++ b/cmd/picoclaw/internal/onboard/command.go @@ -6,7 +6,7 @@ import ( "github.com/spf13/cobra" ) -//go:generate go run ../../../../scripts/copydir.go "${DOLLAR}{codespace}/workspace" ./workspace +//go:generate go run ../../../../scripts/copydir.go ../../../../workspace ./workspace //go:embed workspace var embeddedFiles embed.FS From bd867a16cdf664587f18b32a3011098f032f7ff5 Mon Sep 17 00:00:00 2001 From: SiYue-ZO <2835601846@qq.com> Date: Tue, 28 Apr 2026 12:58:26 +0800 Subject: [PATCH 58/87] style(tools): wrap serial lines for golines --- pkg/tools/hardware/serial.go | 8 ++++++-- pkg/tools/hardware/serial_test.go | 7 ++++++- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/pkg/tools/hardware/serial.go b/pkg/tools/hardware/serial.go index 52e47fc7a..7e197a909 100644 --- a/pkg/tools/hardware/serial.go +++ b/pkg/tools/hardware/serial.go @@ -23,7 +23,9 @@ const ( ) var ( - unixSerialPortPattern = regexp.MustCompile(`^(?:/dev/)?(?:ttyS\d+|ttyUSB\d+|ttyACM\d+|ttyAMA\d+|rfcomm\d+|tty\.[A-Za-z0-9._-]+|cu\.[A-Za-z0-9._-]+)$`) + unixSerialPortPattern = regexp.MustCompile( + `^(?:/dev/)?(?:ttyS\d+|ttyUSB\d+|ttyACM\d+|ttyAMA\d+|rfcomm\d+|tty\.[A-Za-z0-9._-]+|cu\.[A-Za-z0-9._-]+)$`, + ) windowsSerialPortPattern = regexp.MustCompile(`^(?:\\\\\.\\)?COM[1-9]\d*$`) unixSerialBaudRates = map[int]struct{}{ 50: {}, 75: {}, 110: {}, 134: {}, 150: {}, 200: {}, 300: {}, 600: {}, 1200: {}, 1800: {}, @@ -219,7 +221,9 @@ func parseSerialConfig(args map[string]any) (serialConfig, *ToolResult) { port, ok := args["port"].(string) port = strings.TrimSpace(port) if !ok || port == "" { - return serialConfig{}, ErrorResult("port is required (for example /dev/ttyUSB0, /dev/cu.usbserial-0001, or COM3)") + return serialConfig{}, ErrorResult( + "port is required (for example /dev/ttyUSB0, /dev/cu.usbserial-0001, or COM3)", + ) } normalizedPort, err := normalizeSerialPort(port) diff --git a/pkg/tools/hardware/serial_test.go b/pkg/tools/hardware/serial_test.go index 5f9e2a44d..6b2e9765d 100644 --- a/pkg/tools/hardware/serial_test.go +++ b/pkg/tools/hardware/serial_test.go @@ -103,7 +103,12 @@ func TestSerialReadCanceledBeforeOpen(t *testing.T) { port = "COM3" } - _, err := serialRead(ctx, serialConfig{Port: port, Baud: 115200, DataBits: 8, Parity: "none", StopBits: 1}, 1, time.Second) + _, err := serialRead( + ctx, + serialConfig{Port: port, Baud: 115200, DataBits: 8, Parity: "none", StopBits: 1}, + 1, + time.Second, + ) if err == nil || !strings.Contains(err.Error(), context.Canceled.Error()) { t.Fatalf("serialRead() error = %v, want context canceled", err) } From 9b109dc7a852cd2f4c50d24d4486ef492be03e8c Mon Sep 17 00:00:00 2001 From: LC Date: Tue, 28 Apr 2026 16:19:59 +0800 Subject: [PATCH 59/87] fix(serial_windows): remove unused import (#2697) --- pkg/tools/hardware/serial_windows.go | 1 - 1 file changed, 1 deletion(-) diff --git a/pkg/tools/hardware/serial_windows.go b/pkg/tools/hardware/serial_windows.go index 36f8b4271..31a215589 100644 --- a/pkg/tools/hardware/serial_windows.go +++ b/pkg/tools/hardware/serial_windows.go @@ -4,7 +4,6 @@ package hardwaretools import ( "context" - "fmt" "sort" "strings" "time" From 62d0e34ec9fde97252ee07a6186f05f0bb08da43 Mon Sep 17 00:00:00 2001 From: Guoguo <16666742+imguoguo@users.noreply.github.com> Date: Wed, 29 Apr 2026 16:19:15 +0800 Subject: [PATCH 60/87] fix(docker): restore `make docker-build` by adding build directives and fixing Go version (#2700) * fix(docker): restore `make docker-build` by adding build directives and fixing Go version docker-compose.yml only had `image:` references with no `build:` sections, so `docker compose build` had nothing to build. Also fixed golang:1.26.0-alpine (nonexistent) to golang:1.25-alpine in Dockerfile.full/heavy, and removed LICENSE from .dockerignore since scripts/copydir.go needs it as a repo-root anchor during `go generate`. Co-Authored-By: Claude Opus 4.6 * fix(docker): inject version metadata ldflags in Dockerfile.launcher Mirror the ldflags from web/Makefile (Version, GitCommit, BuildTime, GoVersion) into the picoclaw-launcher go build command so Docker-built launcher images include proper version/build metadata. Co-Authored-By: Claude Opus 4.6 --------- Co-authored-by: Claude Opus 4.6 --- .dockerignore | 3 +- docker/Dockerfile.full | 2 +- docker/Dockerfile.heavy | 2 +- docker/Dockerfile.launcher | 65 ++++++++++++++++++++++++++++++++++++++ docker/docker-compose.yml | 9 ++++++ 5 files changed, 78 insertions(+), 3 deletions(-) create mode 100644 docker/Dockerfile.launcher diff --git a/.dockerignore b/.dockerignore index d632da5ea..9ddc971ef 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,3 +1,5 @@ +# Do NOT exclude LICENSE or .github — scripts/copydir.go uses them as repo-root anchors +# during `go generate`, which runs inside `make build` in the Dockerfile. .git .gitignore build/ @@ -6,5 +8,4 @@ config/ .env .env.example *.md -LICENSE assets/ diff --git a/docker/Dockerfile.full b/docker/Dockerfile.full index 30e1680d5..1dc0679c9 100644 --- a/docker/Dockerfile.full +++ b/docker/Dockerfile.full @@ -1,7 +1,7 @@ # ============================================================ # Stage 1: Build the picoclaw binary # ============================================================ -FROM golang:1.26.0-alpine AS builder +FROM golang:1.25-alpine AS builder RUN apk add --no-cache git make diff --git a/docker/Dockerfile.heavy b/docker/Dockerfile.heavy index 2a9fc742d..81f6976a2 100644 --- a/docker/Dockerfile.heavy +++ b/docker/Dockerfile.heavy @@ -1,7 +1,7 @@ # ============================================================ # Stage 1: Build the picoclaw binary # ============================================================ -FROM golang:1.26.0-alpine AS builder +FROM golang:1.25-alpine AS builder RUN apk add --no-cache git make diff --git a/docker/Dockerfile.launcher b/docker/Dockerfile.launcher new file mode 100644 index 000000000..33fdc6d6e --- /dev/null +++ b/docker/Dockerfile.launcher @@ -0,0 +1,65 @@ +# ============================================================ +# Stage 1: Build frontend assets (Node.js + pnpm) +# ============================================================ +FROM node:24-alpine3.23 AS frontend + +RUN corepack enable && corepack prepare pnpm@latest --activate + +WORKDIR /src/web/frontend + +# Cache frontend dependencies +COPY web/frontend/package.json web/frontend/pnpm-lock.yaml ./ +RUN CI=true pnpm install --frozen-lockfile + +# Build frontend +COPY web/frontend/ ./ +RUN pnpm build:backend + +# ============================================================ +# Stage 2: Build Go binaries (picoclaw + picoclaw-launcher) +# ============================================================ +FROM golang:1.25-alpine AS builder + +RUN apk add --no-cache git make + +WORKDIR /src + +# Cache Go dependencies +COPY go.mod go.sum ./ +RUN go mod download + +# Copy source +COPY . . + +# Copy pre-built frontend assets into the backend embed directory +COPY --from=frontend /src/web/backend/dist web/backend/dist + +# Build picoclaw binary (includes go generate) +RUN make build + +# Build picoclaw-launcher binary (frontend already built in stage 1) +# Mirror ldflags from web/Makefile to inject version metadata +RUN CONFIG_PKG=github.com/sipeed/picoclaw/pkg/config && \ + VERSION=$(git describe --tags --always --dirty 2>/dev/null || echo dev) && \ + GIT_COMMIT=$(git rev-parse --short=8 HEAD 2>/dev/null || echo dev) && \ + BUILD_TIME=$(date +%FT%T%z) && \ + GO_VERSION=$(go env GOVERSION) && \ + CGO_ENABLED=0 go build -v -tags goolm,stdjson \ + -ldflags "-X ${CONFIG_PKG}.Version=${VERSION} -X ${CONFIG_PKG}.GitCommit=${GIT_COMMIT} -X ${CONFIG_PKG}.BuildTime=${BUILD_TIME} -X ${CONFIG_PKG}.GoVersion=${GO_VERSION} -s -w" \ + -o build/picoclaw-launcher ./web/backend/ + +# ============================================================ +# Stage 3: Minimal runtime image +# ============================================================ +FROM alpine:3.23 + +RUN apk add --no-cache ca-certificates tzdata curl + +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD wget -q --spider http://localhost:18790/health || exit 1 + +COPY --from=builder /src/build/picoclaw /usr/local/bin/picoclaw +COPY --from=builder /src/build/picoclaw-launcher /usr/local/bin/picoclaw-launcher + +ENTRYPOINT ["picoclaw-launcher"] +CMD ["-console", "-public", "-no-browser"] diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index 7c940621f..b12959fc7 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -4,6 +4,9 @@ services: # docker compose -f docker/docker-compose.yml run --rm picoclaw-agent -m "Hello" # ───────────────────────────────────────────── picoclaw-agent: + build: + context: .. + dockerfile: docker/Dockerfile image: docker.io/sipeed/picoclaw:latest container_name: picoclaw-agent profiles: @@ -22,6 +25,9 @@ services: # docker compose -f docker/docker-compose.yml --profile gateway up # ───────────────────────────────────────────── picoclaw-gateway: + build: + context: .. + dockerfile: docker/Dockerfile image: docker.io/sipeed/picoclaw:latest container_name: picoclaw-gateway restart: unless-stopped @@ -38,6 +44,9 @@ services: # docker compose -f docker/docker-compose.yml --profile launcher up # ───────────────────────────────────────────── picoclaw-launcher: + build: + context: .. + dockerfile: docker/Dockerfile.launcher image: docker.io/sipeed/picoclaw:launcher container_name: picoclaw-launcher restart: unless-stopped From a36472b55f06248e7dca48507df5bdae7a5d4800 Mon Sep 17 00:00:00 2001 From: taonyx Date: Wed, 29 Apr 2026 17:52:47 +0800 Subject: [PATCH 61/87] Add CLI support for custom OpenAI-compatible endpoints and remove TUI (#2710) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(model): add `picoclaw model add` for custom OpenAI-compatible endpoints Onboards a model from a user-supplied API base + key by hitting GET /models, prompting the user to pick one, and writing the entry into model_list[] (with api_keys) plus setting it as the default model. This was previously only available in the TUI launcher (issue #2208) and is now accessible from the CLI: picoclaw model add -b URL -k KEY [-m MODEL] [-n ALIAS] * chore: remove deprecated picoclaw-launcher-tui Per RFC #2208, the TUI launcher is deprecated in favor of the CLI; its "online model picker" feature has been ported to `picoclaw model add` in the previous commit. This drops the binary and all build/release/docs references: - delete cmd/picoclaw-launcher-tui/ and assets/launcher-tui.jpg - Makefile: remove the `build-launcher-tui` target - .goreleaser.yaml: drop the build entry plus the `picoclaw-launcher-tui` ids from the launcher docker image, macOS notarize list, and nfpms contents - docker/Dockerfile.goreleaser.launcher: drop the COPY for the TUI binary - READMEs (root + 8 locales): remove the "TUI Launcher" section and screenshot link - docs/guides/docker.*: update the "launcher image includes …" sentence to reflect the two remaining binaries `make build` still succeeds; `go build ./web/backend` (the launcher target) still succeeds. `picoclaw-launcher` (web console) is unaffected. --- .goreleaser.yaml | 46 --- Makefile | 14 - README.md | 18 -- assets/launcher-tui.jpg | Bin 277431 -> 0 bytes cmd/picoclaw-launcher-tui/README.md | 69 ----- cmd/picoclaw-launcher-tui/config/config.go | 236 --------------- cmd/picoclaw-launcher-tui/main.go | 48 --- cmd/picoclaw-launcher-tui/ui/app.go | 325 --------------------- cmd/picoclaw-launcher-tui/ui/channels.go | 202 ------------- cmd/picoclaw-launcher-tui/ui/gateway.go | 229 --------------- cmd/picoclaw-launcher-tui/ui/home.go | 70 ----- cmd/picoclaw-launcher-tui/ui/models.go | 200 ------------- cmd/picoclaw-launcher-tui/ui/schemes.go | 252 ---------------- cmd/picoclaw-launcher-tui/ui/users.go | 261 ----------------- cmd/picoclaw/internal/model/add.go | 200 +++++++++++++ cmd/picoclaw/internal/model/add_test.go | 257 ++++++++++++++++ cmd/picoclaw/internal/model/command.go | 11 + cmd/picoclaw/internal/model/online.go | 77 +++++ docker/Dockerfile.goreleaser.launcher | 1 - docs/guides/docker.fr.md | 2 +- docs/guides/docker.ja.md | 2 +- docs/guides/docker.md | 2 +- docs/guides/docker.ms.md | 2 +- docs/guides/docker.pt-br.md | 2 +- docs/guides/docker.vi.md | 2 +- docs/guides/docker.zh.md | 2 +- docs/project/README.fr.md | 18 -- docs/project/README.id.md | 18 -- docs/project/README.it.md | 18 -- docs/project/README.ja.md | 18 -- docs/project/README.ko.md | 18 -- docs/project/README.ms.md | 18 -- docs/project/README.pt-br.md | 18 -- docs/project/README.vi.md | 18 -- docs/project/README.zh.md | 18 -- go.mod | 6 +- go.sum | 8 - 37 files changed, 553 insertions(+), 2153 deletions(-) delete mode 100644 assets/launcher-tui.jpg delete mode 100644 cmd/picoclaw-launcher-tui/README.md delete mode 100644 cmd/picoclaw-launcher-tui/config/config.go delete mode 100644 cmd/picoclaw-launcher-tui/main.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/app.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/channels.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/gateway.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/home.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/models.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/schemes.go delete mode 100644 cmd/picoclaw-launcher-tui/ui/users.go create mode 100644 cmd/picoclaw/internal/model/add.go create mode 100644 cmd/picoclaw/internal/model/add_test.go create mode 100644 cmd/picoclaw/internal/model/online.go diff --git a/.goreleaser.yaml b/.goreleaser.yaml index b330c60f5..3e747bc35 100644 --- a/.goreleaser.yaml +++ b/.goreleaser.yaml @@ -100,49 +100,6 @@ builds: - goos: netbsd goarch: arm - - id: picoclaw-launcher-tui - binary: picoclaw-launcher-tui - env: - - CGO_ENABLED=0 - tags: - - goolm - - stdjson - ldflags: - - -s -w - - -X github.com/sipeed/picoclaw/pkg/config.Version={{ .Version }} - - -X github.com/sipeed/picoclaw/pkg/config.GitCommit={{ .ShortCommit }} - - -X github.com/sipeed/picoclaw/pkg/config.BuildTime={{ .Date }} - - -X github.com/sipeed/picoclaw/pkg/config.GoVersion={{ with index .Env "GOVERSION" }}{{ . }}{{ else }}unknown{{ end }} - goos: - - linux - - windows - - darwin - - freebsd - - netbsd - goarch: - - amd64 - - arm64 - - riscv64 - - loong64 - - arm - - s390x - - mipsle - goarm: - - "6" - - "7" - gomips: - - softfloat - main: ./cmd/picoclaw-launcher-tui - ignore: - - goos: windows - goarch: arm - - goos: netbsd - goarch: s390x - - goos: netbsd - goarch: mips64 - - goos: netbsd - goarch: arm - dockers_v2: - id: picoclaw dockerfile: docker/Dockerfile.goreleaser @@ -166,7 +123,6 @@ dockers_v2: ids: - picoclaw - picoclaw-launcher - - picoclaw-launcher-tui images: - "ghcr.io/{{ .Env.REPO_OWNER }}/picoclaw" - '{{ with .Env.DOCKERHUB_IMAGE_NAME }}docker.io/{{ . }}{{ end }}' @@ -184,7 +140,6 @@ notarize: ids: - picoclaw - picoclaw-launcher - - picoclaw-launcher-tui sign: certificate: "{{.Env.MACOS_SIGN_P12}}" password: "{{.Env.MACOS_SIGN_PASSWORD}}" @@ -215,7 +170,6 @@ nfpms: ids: - picoclaw - picoclaw-launcher - - picoclaw-launcher-tui package_name: picoclaw file_name_template: >- {{ .PackageName }}_ diff --git a/Makefile b/Makefile index 0f6a036f4..3fa41bc24 100644 --- a/Makefile +++ b/Makefile @@ -236,20 +236,6 @@ endif build-launcher-frontend: @$(MAKE) -C web build-frontend -## build-launcher-tui: Build the picoclaw-launcher TUI binary -build-launcher-tui: - @echo "Building picoclaw-launcher-tui for $(PLATFORM)/$(ARCH)..." -ifeq ($(OS),Windows_NT) - @$(POWERSHELL) "New-Item -ItemType Directory -Force -Path '$(BUILD_DIR)' | Out-Null" - @$(GO) build $(GOFLAGS) -o $(BUILD_DIR)/picoclaw-launcher-tui-$(PLATFORM)-$(ARCH)$(EXT) ./cmd/picoclaw-launcher-tui - @$(POWERSHELL) "Copy-Item -LiteralPath '$(BUILD_DIR)/picoclaw-launcher-tui-$(PLATFORM)-$(ARCH)$(EXT)' -Destination '$(BUILD_DIR)/picoclaw-launcher-tui$(EXT)' -Force" -else - @mkdir -p $(BUILD_DIR) - @$(GO) build $(GOFLAGS) -o $(BUILD_DIR)/picoclaw-launcher-tui-$(PLATFORM)-$(ARCH) ./cmd/picoclaw-launcher-tui - @ln -sf picoclaw-launcher-tui-$(PLATFORM)-$(ARCH) $(BUILD_DIR)/picoclaw-launcher-tui -endif - @echo "Build complete: $(BUILD_DIR)/picoclaw-launcher-tui$(EXT)" - ## build-whatsapp-native: Build with WhatsApp native (whatsmeow) support; larger binary build-whatsapp-native: generate ## @echo "Building $(BINARY_NAME) with WhatsApp native for $(PLATFORM)/$(ARCH)..." diff --git a/README.md b/README.md index 73cc877fa..30ac67d8f 100644 --- a/README.md +++ b/README.md @@ -291,24 +291,6 @@ After this one-time step, `picoclaw-launcher` will open normally on subsequent l -### 💻 TUI Launcher (Recommended for Headless / SSH) - -The TUI (Terminal UI) Launcher provides a full-featured terminal interface for configuration and management. Ideal for servers, Raspberry Pi, and other headless environments. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**Getting started:** - -Use the TUI menus to: **1)** Configure a Provider -> **2)** Configure a Channel -> **3)** Start the Gateway -> **4)** Chat! - -For detailed TUI documentation, see [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android diff --git a/assets/launcher-tui.jpg b/assets/launcher-tui.jpg deleted file mode 100644 index 659c97794fe251de00d076833665704c0a1a5110..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 277431 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

OF(k~z$vpn%D58mJYyIcIzfxRH2C#{2hKa5&Ul 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

uWp!=y9&Q*y- ztjn;&oK7Hxub-yCsJWi1Gwd=U-oQuuui)S`!C?ZPg<;u&t4(0i;@D|C*8;c6J94-&esoV8yvfa3b5LH-Zhx_Vi>N3C7=R&}xfQbZAiwE8v?%ye?&o z453#n)g>{u*yTz4^4A1aksg%!NQmS7G9c{07=lkYfKv6Ttp6s}^D(~o36QU41d_II z0RQs!M6^M!06%`VbTsy|H|_7RFMq%!zU1&=kMn&H6yKzF`+469iivex4M_1Dk)Af0 z@#Y)w{Cb2igwMvKtG1q>>VI<*U$9VF$12$JaU|so3J8;pi z%Yq^4>Ducd@4#@8p8LUFBjnLtC_YH&_3ojmY`H#-d#mx{UK&^k#2BoH(j^8xS;@-D zz2V^(hIi>|yyY4w-XvF{{np+DPwd)RVDdPODvl?Vd7{*EI*VV{AUVr^($3)n7W(@s z_a`T_^~-pCc45Ixizs8-zr29Vk1v&!h5zzr)GJ?E&Z70!YXFy~8&k7HJP$kG>bZ(J zTBz)%FZEzqWxlDVmiUclH8xfH&VWr}`HS>2)d#O(d@BNW4Ul(F`B5HZ%^$Q^#H4IS zbi!_FEKZlLuse1#x^X`X@3X~ob_Xi6o%*vYXW5UU0_$nAJn5_OH#zC6v=F4mlAdy5 zwm&*GNkcvu>lGT;J~O$m%`;VVlKcA(`A_N2(cckT=6c$J<{o@TQZgF=Kw_7A$@f$#b$R zgT+zGSTxkbV!qxPcc?pinAq~*g=(YFJ!OQZ2rA3iU7)gm-z@!C_?u!=>w7`-v&zl< zhO5DP+NFYX#}hWo4ZuwtR4w8Ksm56HxCWPC{tel8*5dCx*}a4NQ*9zYz2DO7C^K?? z*0NbV;maV!P0ZIQ8^Uzf+4#$olA99ywb;-Eva zVJG@dyom$2R3lWyAT41Yz4UuJr}-0}4D-CQ$ka(58vYDXE3C0aF3747Fh7&C^>bY% z>iS(M=vkuaExl{1Ca3O~5G=DZpg!%K>;l#8Wkw1q`J6&TM0^7wJYy7U;Sms!(1DU9?R zr21J7+MCQ)EVG|rEov)}aAwA<_IPg*@bZGRTH3l?8kPQtgvA+k2Ti)b$-bEO{4SqY$b!`c#fbxB${(=yb%`kp0KQS+;17 zVZ-K^3ILkxJ&(m(mjyn+^!C7+9T&-Flo*`NsH$CV#r~|e3n)=MOx#2~+jpeo$ofEI zcfRTVwobk_zz{|oXV+Z|^XC78ei;k0l$R)v8~C8h7=r8@55darC`z3bO=L|S|MF+m zdp58iII=01ilH7W6vU2nmBFvVU2Ga$7&5HAa;VYiHZbqV>ZZp%kWO0*&YTswR2wL3 zcxQojf!Vi+nGkL>`V{pb5}6JJQ67WaO(Q#5fti_(*N3-e_I0Q+#Ol4((+CbeF7K*i$UacrRs zt1o|3HErVmUmv7aA5=JgPu+NUYn~MRYTy2N7XP;bpD3k*U_c9L0Va?ELN3nLw&nkx zhYzLyZ5}#?MAy>*Ay-B8&%Y(9;rs1~3I6YK0Q7pl0UDD3x7sp2waL%$Lvmp5Iv!sT ztp=tou>E5OfXMG3Gx#seU^^bWhXj*2TG3C{TFPj_MBO+;-zP6xKBCE4XZp62Xsp_= zK%LIsxDEXSl7lw{ap+!#;K{hMZ*F+tt`kqj^&LDrRAq$WyvXi$q9|kPf6Nt zcHfFLEXIE2cC#azE{Fhhe`8FA;Ur=1Pqja>E<1=|j{Uo)@R?&E^;IAYRY7v>i{+lb z`QNob?B&2Ea!YLgpD&TKRC^8V3?EGRc`Q2zP-#?K;B{2^aZ62g+9%ucDP3Jk@i%A9 zOWsWB-@dE(+!bMnBBd}V4}JQ6mA^+&L;P{MhS&2LXM^ONW4%PTS?5DbDxv;ZEmg~O z>mR)t<$*UvV)?$SWfYh(+_`?BUevRn2uV`6+ASzPhvFYiimm`rN+j-nkHUOSWzsSv z{!`+Rh`l)^Rgq=1S8zW3Mook|-x@i;+*KA_IQrI5PabgEe!;d*fACa18Vr(bBUM}- zw-|f{!}nb7lTdiYd5LKF@~b=|vJ<~9IL4qA+6AsrjmMr4Xg2HW<#k{C0)LOE6pa?i ze`7o2imrD1V~h8pI?Zl~a@XalkkF`ik12AQrrX_GADEoKlNyk z-5v&tOSLK&AfG+cNY~QW2`oty^jWJ8~D-SK=nmy1ea}Yvn z7*69+uD`~EDO&nqPS(Cwl+=@O3f-_&?h#*|S zeo8?@Lm5wdGFJk4z_SoDs+^2Z`DG)l;z%3rY`h;)ld6VdS;-@da${T)dV~Wv-(xls zLEwct&&9|3k_U^_dY8{uRf*L)y^)|AU!*1cp}~~9KDo;BWh%D(6ZH1gcefq>7>co7&)p@(W*n^Sbwla! zk6TA2flD5T&n2IJj4Y({N*^#(2yxEcVJI-;-^s63yy(afx7~g3vb%1_qq|UrU}F~GrMg9 zF65;{Xt~@wQ|3djp8AEump{zqyk6m$-RLgG zbat*0F5#s)sCLUTyJlz*k(@V`II0MfIiC4)6S*w3eaDU~O%@APC+*F|7epR?u#wvx zYb^?4<>@*p7S~94^P=7$(W}K%omlX3++CSaX4Sw3(M50Neu?&~XkXDQ_!z9ikMb2T zgXdnH=}*0mbgk!CVj7yeS|-A|RMZgvOlLrlVEkkX$dJzv zDOox7LGyas=a;)@!khAJ?HIlGxpuuAa>z^#Yrr;wRE5j4IrhFAyKRH?Si|kFcgb|< z-^wj7&vds}*LQFHFO z>uw1SkCp|BSt9GcKEU^J>^iNqvL2_+fSq)S=T%U#eik!JkcQFFiLIMF!{|9y!66Z+ zMJA=uq`CZ}q&`;)QJM70ROQ?%TVO>#Z5~5T5z#GzXZP^30AEOHHs@HObbD^mY^dn` zBT6mP@7NQS&YYiUWST4E?|%(F%QeH!8VQ3lu(6b8&-5*7cb`4pjsYMnOR(PC7k7=_M zrI5`Flhv_M%qX+)E~!2xs2Q+E`7hO@O43_YERdx7dikrEskOryWIQ=cfEp(x6X{xW zrY*B0nunV)Z>d*Ps}JuQaPk#oQ1yDd(931K^SS2+r`xwzIdBEM3O0CUYH7DxYGJN7 zGCXoONJu)<2{q>TLYPq_`myvqwev*VGr`W&8;tKk6iU{zNFwBhC|S^GJ538ewlYX@ zZtE%h)(}D+;SBK-`BuwcQ5a{w?LV=>t}@rV_NeUEb6T>`=(YpkV#(z~Gxq9YsT6{b0b5%vCFlvnPgR*J2`<*epG?W*8vq)9Wgk%Xgb0k>@`DIeG-Ko z@f8e>HR-ug%F(Smhd54|0y|w0#dzbb8!?AgM%WQxWK4 zE~q`AG@BKd`=!ov6Od*?Yr-h?w>83;P@IobSy``UprLoa5A>2=ElrgJ9kydMzwtEV zywChh=T#>xE%BFcn49;IYl6m|7G(|NxR@QD+mkUUb0t8@2;*S3z&lu^)uMmGroGV<`JEu3W}_Ao4YmWb zY_;)@O1=blHR(nic8>>YqslduiR&sIXup#?&i$DGo(@WFX|Rd*zxw+4EpgxxJ5NU& z_(S%(Y!idWy%3DA=WGx)gGOc^guguP0S%i7_W(1m%5;2<5o@WQ{xkkXzH@{m=1OGI zIr)J*X#+>tK}>TrR%>z$j*5WP91<_6;<^WYuS!$WN*#h}!X=bt2=gSqQp07@aeBsk!Z~qh<{g%Aa zOC9k>5G|p_bA=?*unIq(yL3gf>Z{*papZap^=ZzPagOLJTaSve(1cfZ3;EZG zmeK7@g4-8Fvwp`_t>+m4Xo#4;nL}QSeS!-{ot0lReJ1tJC-0MR|NStuWK<`{qAH?_ z(>~(XQb1e~;*B?mUAHTpqL;%Ig_-1x+9+i*DnbdQn@w)cN!rNAHYG*1Jlzdw=Jq~m z-*iCj(cuc0!Aux1$(qjrP@XA^0K9GLboa7{WTm7BNIk^{TbaWt-evvSGseTj`M|T( zOlcx*wnM`!2KtQyqoEtQbfd-Q%vw4Zoy+7hcOD*zXI`;Xv#gvFU2CqM6cu*OOI&oQ zORl+*p5w1kQ1yUgSouEDmHm12(~>|n+^dMoCAg(-=aOreOSWg0iAacuh^~A_*q$fC z9naclAu9~=-OZw8^SJ&1VG_&Ho=D#k^}O!8+t0CIX09CzDr^|n)BH3c3_pC=;oGZp z32kZDqJmb0cTp47y7`$;`KH#IQk1&R6&(KhM4Vj0e3i$W>Fq~G@`jQPqCtrlvcvR! zUMJ|1nL&?t!+ud+_YrkjAHsSb_fL@qI7fDB6qqrEp;!`=Z43Cjy$g9eteEYy#17wL zA#wMz6w_Am)Ln}=aoWg6X^ZDdz{IeakeeAN-FVQHlTQ;<7scJa(OdO2-etCH0QA=$jZ~;J_LUKT3;@o0@ zFZm}xM)OhG2ko{8t1lOnPvsQS4wSNb<|`yw@}#Xi>*+y6Su;6HikQ##L@HHD^v1xZ zz(HmTh2Srz{!GJ+pjCaP?anCXH3|}jvR|D9HcVZ)jtrWtfsLASr7F;uoqwRvIH?o+ z$xbMjB)IT_^hlbNg&T#f^E&;S2H32eU+QTq9f~0?r5LY|^DA`u$TQ{+X!iyzjU3$G zW-Glko>r(7w0quT?XWl>#>jiOfpNCFK^jv3UPe+#{kXbUtF*%p|DJ0V4$1b7Zfr(cl&(nO-X~5r zj^B+sjk-}KqlHoV=oL|?@Dvr}o5@f~hKv`v)k_#-U8X=4%t#!831+T5T?<^HjaR6~ zsKlHS*F{R68m9<%l7w=ZmxI4b3>|y(+(||CDX*vZUDm)iU~_wQqb`VUwD6<$h+!i= z8TAo?3Mh|(Jd-V9cL{TTnv!cx`#1NOdnyI;7A!P2xT?jtX1)jA1a^KJ)B;A1BwWRz zFfv~*h;BW>bXS=<&gDjK)YrAvM%~yXHRTztbplPko}-o+qOjqHU5z?PI!-))A9xAd z9eA&e5=V*R2nJ)~K7CBgC0l$T286&hT(t>tAD@g#CV2qov^}}A{ec#_P$~Q9Ztf_q zUTi?Z`Q(#tDpuzXXgG&8H+ZJFPc7Hpg*aQj3v*e8&ygHAwBfLrJQPXib}q3Q&Wj@iGe9BV z#WFY-(=_wWO}K5-jq7u*CWutinzvzCEXUjA#nP^#Um2kX7G&;6=Fl7gGjvZQ2!@odlggQE@w?&m)8r5Jp@cCPos`XAPd#uG>6H+Ag zv1n)fEIA7ChCqa)Uh&%{K2w8DphUxicpmzKNjKSvo0`?1y-#ITr&$m6Da8>cKf&5Y zw_n%rldOF`oj-m%uEf3o?~oVe!nnucb+OPt#%h_?F&oi%KikUfv1;eb%oO@{?>;@! zyIMV;-=-{lgZcUQB#aD_1IOoM#e!1?Y%rI;?JA6SMLKwyPpKEhj92p|F3V8-*zHd5 zsYc&)v*;Gqogb{5mK?R({(W*HlRHEs{S~Pnq00oBP;8Do*YM#=S=XD<}f#woOgv{CG_B@ zVELCIx$%|3QqqtWFsYXn%}@iUC|bV8%e6W5v!+Og=QCMS+74V(r0ozY(X zI1Xmxx|@kd&~NcwFJ?m8pSaJZbt$p8r)f>s3<>HrP8?moY9FAGzEhhPg}!q4QK^tl z$=5S=eR08TV8>hIX1d#i#@k&f>ADD^irjIj4rLWfiWDr2{NzR$O0X4VugY76RQ(JBC#rr`r2OR?l@IcTimHs)Le&T zPaIZw`qwI@;%9du3chD@&{>D$f|m1laMZJxNgc=s$80>t1<1_#`uiYu91-}P zEl+=AnReGiuuQbWK11CB-w3!h8`6G z=^cUwPvdPHGxCQi; z0w%q-44x0Cp1FX(qUH?#0h{vudOU+YR=Qz)<^11*zcq=EHp^x2^ORa3ek$6*B38pZ zT+j87Ej3u}JDj}w@sG~aj7#SDRCAUEY8%O@i6UF@$xl^7rP^Ki>ZIJy*}s;Xc2q06Dz6Mv*ZsQI5qZT9nGiK5m-En|9h&y1SmKRqewX?LfBL5_$&!(H za9+rYxx~ZglrrVW z%LoTNy!Ljcl1XMt$5=u~asMcYyaV~Du9n)PNm#n_L9tL<&HVDSk{$0b2tT_ zu1|{4muF7R(76yQ>X6@Dd|0vngIZ4>AgK+Qnh(HO;wC&DO4F;SP*v@YuGQb~;<(Rl z-MO0R`RHmoOwl0URwV2%^O>&t(&+;l2MT?4l-bWTf15EnGEBsBZE5tf0q&J!Va)na zJWIp6kL04pTA!SbBz4G)8cW*Yf)D*kZp&XORdeYz?uMNI7Na`x(=Kab>9fOJl5ZX9 z^T=tlRoRzpG7Y#OL&$yl2&labMHVEKb&|tz5Y`?wN-zOmA0fM?BSc}G3R7?}4LeX; z_6wV6)eUM_T5Kke%w^aru6%`S=ttzw5HCofibF3*P@L22wZa-;!+EBOCd(WFRw#~i*OP$|| z3x%=J&XPUQLm<|rg+=EL9l@eG!fgGEQuimOw;riDt8^5cO#jEH7oNzFk4j3 z7;5sG!!uKOt)SAl0T#2$z(f6DD0^Xz@01l%NKDE#pb2AUDxsOvxex?3+8m~=$5Kf+ zlUg)g7P*p{tP!5nqXtb1grBDg5~Je_-NWD8C{n7P)yCnciB7hzXoOzkSU?WJHt=Q4 zFfS)}snlr6cSGYbh_CsaC=PP!=ME#4I7`%dNiinmr{BwqX7!%0`t=KU(jnz@+#u4M z@%ic(@sW<(zCK9FB|ioS8Wq(P?Nz>@hF@+y4~OYbsmKC}&3Uqql>tC&pZg}R)9>zK zXK|oq+a@LRDDM*sJiWs)sKFJ#mziF>27ldP=y(G+MfhdomSr88U9Pzm!@O{{g`zGb>*FrL2<6d}d_YRX;BD3~Ic1iA#*HdwXPJ$F24N;< zf&(5)d=E7;&X=>0@=pW&kI<8J0$q_PR2$zU3?8BeU(YpxvONgyIpB!@_%=6~pUC}o zNEv0$Z2Rt>WoW19Owp?ej&A`*vR2F~c zji8%d887Q$IG!HOyh_rY@pA#!j#&e8JI=onf}DaL>Y>6j-&zjt3NsJYkiaDHr>b(B zToY4Pectv)>;rOEg?#OUsX*&TLs@}U+b@}ovrP3wDZd$B=JS1`u;U?B`9iBS@atYizznaKGxbP*d$VF zB2TXDYR`;PW$oT))LVcrVi9CB-XEYcyVdBi&M3q2FdcAuukpE`vJdPIb`GQLEw4KP zlX}vEQ>eS$0DgNskQTz8)XP2-1=0--C7IrEZ0#U#*XQ`kPLIB*%Jn6r|0y?#owx(- zy79-k59$v)3hwQtAq6Z;YHza?t|%&3oZB0%lYH>TCRhEoi>Ij`Uh&wpYHDB0`a__Q z6(KQ+rWiYLf42w5K?d=CRd*WWbNo&<>EmRQA)40B^a!9Go}u9@h=MYQeLygEfu zMoEltQyPN;NQ!>Dka|ZvNVv~^ge?Wv07tGI#HhUX?6=9Zoz*gqb~ow2DPp<1sl<5q z=9yDv;LU9o*a@;%nVN6ZMQPvSBJ42Jbk7dX!_tKnTT&)SCTleWu1Tu}ZK}{B(NV3LlU=m!fkXNRAJzD0ccf1lkS$+O$9#gDzRs zCnIk;wTdUERaaXfy)q_Ne>2GT@Dl5w9PnR1y;thWpTXG^I#SUvMuf@7W~Z?j>OdTP z^Hds2hySBe9ZDHb>QLh-xZgCKDNs!Kf;bD(L>a5rrVfy7OvE%Qq*>L?ipF~{iuTxG z^z+eG)Y@Y;7_iY8GEkf1Qu(4YF$zi2tjCqiPMCZ6UhYvdcT-D1j^(d{^*DOK7Y9XM ziwM0yp3#4&j}S)Vp6unP-K2sDvL3iDzY>}4sB6Y=D!lS$g@e1D?KZ|dMZ()65}Lk2-2vH;e@w^JA`(Osd75lt|$&05E@r1lh2^f`q?>u(f4XzF{{ z;4+pW_>)uFYup`BaJ@NOa(yo4tY^V`L6w#?dUdc>#?vP_o?`p%SeicbiOs`l zTGjZ8G2_IHv)R%2-FfvopOREju^pLnDRqI&di*H7sX5LCJbllb%>x@HGF6Yjg*Q$8 zN;leNzpfN^!|{ugA*fJ5!kc?Bu7m?-5H+~m3do<`$}fID%6s=KUC*cX7Nue5#arItnkl86zHr{nNZ9O4KOWWxvBFru8UNft>&jnGI z43rRNo`_6&DQ%agtudacRJ~#NK%9pcMFtdkl~fqu%s_4jY)<%^OS=2F)Pw>gQV}-& zT6%eb?&eqoD0^n5Julz~OQLd-eV%CgH(hoU^?ggE+R?* zdXq0~vjWR3Z`?t%$Mx|dPQ9l2QQuIYW)yn7?5l4&S_v~p;3q8!8=}5CA>*=c35MyD z`FnDABCJ;)^fH{}LwsSEqeggLM99Mq*YZiriAz$4t*A59_^FL{&YYNQS=Y-Z=<2ui z{4Z(Bwh69@(eOZEO$D{(qajHy3>5P?EsbLlgd+KDEAfUv-3lcvJKQZexI>GMrz|=TN>*cC|sgInz%zO7jm)lx3a1)H|2*v7+`gpBA%(^xf zbyB`X8L$4Lm-4DadeE|ZT~L)qDT?Gl7`up5pXUa$U!d#=z$1u!X?73}a*1JoNdzHJ zH}*YYbFI+b18C5)+g*|#MB-~Nqt(-dr0z=x?0eesmozi$XPhq+uKRuqHM`sxmZ%22 zAfE^DE@vitUim^iGZTA7+K(-A<9l=Y(h+Q`i>{t%k;azXTMd6Sx})A{afDVNpw#Cp zkmN8to6$OfaR9q>`mzIWM|ypIOW#E=1=VH)U-YERsf^sxc%5MP;JIBv#<$ruM%{+K z6&Q^hij6+21*Vu|H~|&|Vg8$eg&o@kl($EWOv9X|chFhzm`Ka-^!d}gxgqm0@9;>` z!%Xp)XvVn&Qg>p84^t0)K+@IK?cJn*!KW99hd zHV&{aanF~*u!=4CPw(OE-AKjPWsEtn)FQ9(=@!btLmV^3$PX4 zpoV>KzP!^rup4pI?6{_HE6Q4-PTE5A_8B+0N;E&4EOVt~;~uzedEFCFK(U^Yw0a3G z<`B};Y;`AC+{!gne-pVpVgBB~vi-6x$()^PAU_%mW2**gNnc&~CkFxX3TtX&wcO7iF_4`R$hv#5waE>n~03zxpVAAV{~oNgJfL6WO_= z7W%j!&i1mh%Eur1$fC_*2@m6=ON-}Ry8Hrp<K9w_+0Nu&59d|<9-h_XsXCj> z(-HcY@YzLi^V3Q6FI5Ga9cBE3%?=2weD~iBR#*$btpd;&@QYDYUT)3k#J$v=@KO%0 z8mt(xWP1KH3s1?=lV@tyVMgYCE&r39qelaGav8pk(Fim%Ee;G5lqS}7aeVBk3271< z;E?g5-cYSb86gx{8r*~IS35eMzb=A4 zFm%r{@OWS-mSs2sMGfp}MfyxC4!GMTtU6v!L8VkLp^91!O&hwvbFx{6vh2T3W9V#y zG_4gsjun%hogVOk z$9}>TLYKTwXC5FsfMO5wkK~@A3@eREjzBwAg1vZ8@1&fZ>Ycv6c4%jt75w2|r9FW| zo%x*_BP4G6V0LTu_zAUpCHiS7dmLSoY>-Hoqbc=vWDyV&#Llb7s-2~k-bq=Gr8lh4 z3b@$1@@3U@++{iq^6Z~$gXQ<^Fcm!TTKzN{R8(+YqyD@N*!ul+=zSXvs|v5tcsD+? z_9n!J?e`EfWQ3Afgnfsnwr-U8Z^x zZVzSK*685k&v`eKP(o0}*V6=D_pxFs3`#lsjL0ToPp-nPB9ne@e)tjcBwa^dXCFNE zA-$fUXd<4?`1CgSvu9V{@a)gx`{oY_5;#cW60I^# z-!1GrVmP}ZlzCI`)!feF#~$;88O6@;?up+jgPbxd=a?FK+v0jlaad|%SgPmDzQSPBSc@(_qN=xvwrFXuHLAVDtOfJZb;c6vS&RDFD6?Ali9o z?49Bgz6ME2qua?YuDy^w zEoYWw z+6F%#q%7_s6(MKu$fj$Lwv*=mCLzHu;pYzBOr&uDvs%Y@bkqPZ6RVDx84|Wg0yCn& zi8j`(%$BQ=eGT+>d2&Ck7=AA1o0VpD3V&`S%3!tzAwV4<`9E{f8K+-`vsn5a(zoOihnor#>7QcIO27outvPP`inl+waK7_+IrHiCHa! zI`8q3$Z97sj-I%sg%8}~Eq8C#)QkSbsR~j=+08&!DgiM%0v2)7Nm~9qMu4Si*=QP^ zR1pPBZ;i5)8o|f!ng=DKp^OXXUfQfhR{wFjtyhRYjKJ(UPf zk6Ix7D6Wo-)q8uaH{n#w!jc-PYB@0~n<}Ju8(9~K`f^hpRaFL{LJt8y%}hSq5i(@+ zEJzVckcb<3G#alyy`P1fO}Kg?-GLmtAG9x5ZxB8>|A{8bj)}Swm>J&_h!!XxFP0;Z zrOw98jh%U@bvvGD&bDWA-8&uY_SgFfLJ5*5%T=VvZB7Tw$4`3HGgEe&(a?Z})xI@9hMzx4FHZ!t*vfy7Z~35HX7EF1?=A^+xA6v?+kWks(A(`P zye3t7Eew+;x71BPe}g<}NqqxkjsmSzH$q-Z(~MSd6+(4f_^@xPr7mJG3BSwY zR+?a+sqMW2N?8_a(2+z$P3vfm5Wa<^rW@lN_>#vGU8lsl6C}pZ7V&=aV)H)Tv>5Hd zHgS@}Pn(SMjSa7+`JOas0X4_{vI&Ui2_MEbikYGl)5{wP{xkD#WYEmg4tl@OJ!bWX zM^lqhYKAk>`ySVi1i#h>`J|?v&QDpWgSXy+M0;J-gqHY>9N&_Yw8;#8_sm* zV}PZ)SfycAeS)p)1sVIm)bqZp6GDPxHdcn#~1QUnDZi8X#0 zTP=BwMHw*c(LC(sSl74~nT#coTLM2zs;1Uj_UY)ba~w$^qsD$SG>5-8Po@iyJyQF8 zqSM|Y9LH7DdE~U@2^(^#kjg33k!HOrW7Z|XZrk?KL5%carEE{-j)|Wz7}(V(t*w($ znp76ciG$luB37OlC;$30dn^B-so%c}=N}P7u9Iumv1Jyq_^XjYUN@fzp-S~;qQ*jr z(p$m8R-10@BTiY4C*3_{Mo>&i)>AHpO<#ds{CQm!m$o&Dc}C( z3LNdK<2~ZU=x1d-lQjP-&mx;xgjuGoWDtA9#U*ci2}8#W4@KxIEj?AhgPxbTy}w$ zWVb|fk&DshRlF9Y_P8i1__Kb5RoUbqAYvj2YhyjM{0XP4;_7kyS~7teOS*tnIFrO1 z9S*dsWY<(s-GD&Jdh=c6P&{TT?mP6TeLrGG%dtMXUnxrEOMl(wd`7z)$YCg7TF>qn?F}=MOb0)#=#dN6SF_lp4 zd0Q;dc}#lX+RQ__8bMER2`6|na}K&cNeSN?@Fx1R%O`}CgQ#4%=Q5ASVngThWOdxZ zTEUuHd5>cx<|_&e0$we14qU3uV>ne0cto^Nohjk{P+>kY3TQ6_Dp>As0^xEC*dxa6 zR{V=Z4fwb#d97$uaBr98>5CFl%3<2VP5k#EpvGnJE7<)3%#hv(SD5F7B@j|h_gj| zrc?<^s^h0mAdY!sU!Jt*jB4OBf7u@r6(Z)jyVv!luhhdPWjdS zP|>#a?r3n&BPs`;$KG>S_E%JwzxFBZ+2NV%KgiZ#(ETV(l4D8;6t3qEHJq(zwZu3!&%*$6^y55FP?x$>IZJFF z7e_o+Evv+koI0#>a$RSpg;RE%xi3g>JDvd&%<$to8pKn{BGBoE59pH@ znoWXy)vgEfa+oDBxn{0*Iy5@%z@Z%@2uc_s9P^7bb)?*{seCa=6f0!lU3Rz0xFtSh zbWH~PFav&4u8<%X(&0vEV!aT~?;2orEpQmNWUM825;Oir zAFesXBw(AGhP?E%q~3fUEjxJKhptU2k3r~SsGEcxpeLRX1|?lE&7nr)oR|s&mgKcR zD47f-HqI^i=dBe)Ne)S1e?3|at$?z})@QGAR7sI+nYf%SD{M@~r=t7KRb?IRsNTnn zUR_(0i<=Ia{iQ|+HXWVm4?2qPcD9kvv6BF#PdU(Z!7b941nUgv@xI%QPsJWhFYz3VwCY zm!?W&=lb$qPKMR1mK#4qx;Yh>#rERQs86r0|G0kRCeOb8+Wj2N4N_W#@-XsQMrd9@ z4SG#Apd-yhh#V0HO^RB|6IKP|ZB`b{M)bq2vKHx1YyUhHeXvhSD`@}J)RGa*#|A~ z4(9D zw%W>(-t#l%_ti3b)Yk3oz4B+;vJSi6z52MepsN+|aZR4R^8y9)5c;J|1NiqsT?%+* zdKqml7&X?*KC94ubv8x7*K{oYO!>F1J8v$HU0iyR;6U4= zDpP`S(Wj%X!k-YKu@ZKnW9(lHv<&4HoZpM5*!%q8PGCQ?CdMfWu4Oo7sa`#z+>_5T zKsA#b+JkM&usO|V+)qI!qDcy^0aKo4@f)TOHY{wa)bT+^rKBGYrq|OE+T?7Ui^vgg zAm8|A8coxQ8F%QPFjsz-Ojpw&%JGivF7Bxezn!bwAdvyJxx$EB?p^e3eImv>Pj#Z< zq_4F?U^3qLF=Shw=r8OUEuVondsurO~Wfjqkbzuri%g$dgZp>%F>J5HkMK|n{tk2#E z2|Rx>>HLcu&=-d;;>bLihZF(7$IU75I(_M;ShVZgX@#8c*84dG3*rWvE88kC3O6X# z-?lY=a(PAgM&@sZX&>I(17++}Q2ycZi<<^wK2&r!OrR@_jy?+XAK%^^@B|kKupk;#u$GfqcCUXk|9j`{;R&voHUh zUUcU`#^WT02>CfYm^c8U80;BfRRBC=8P53FJfT;T3Y1N(9dt_1mWtO|jwrPbbM|y2 zgGFOLD*bU9l)uU^+`8Vbkou%>g{|YZ%JZ|LjB$R@Kmqkp<+PH=Q#`G#dI*&-CffFv z#i^+|m&?JPt+V>X;-6eb#x|jy+aPie%^8>h*9D=U27=E=m1y)HC7gEj4T#Nbklzeq zv#I0G<@1N-Cuf1Xc%Oe55fwS7GYT5a1SsD4b>hz9FTmfAd?}i4SV8A2PwiWuH2{7G zC|?e*^|+)!TK6DFY$(8tQ+{`scKmiffNuT7fF=*&iymtL9?{du-weB^|GWrQ;!lec z6fk$-lW#PQIXXXo{YzqV;%>z}gb+dPrbmWE)6N1tD_Q@t1Qg$^%x%ONJr?K+TQR2f z^yzGAmq2obfhDqx;g*wf`Xf%o{ zDZhQ2tTTJJiE2(dq_KO~Xc|`QRxIc?ZG6f~mzbaUx@suqE3NHKOaUY0IXpU~$FcYJ ze8RXm&P;&`jXaXJDOoK!UK0UDmJWteUd3h`-Bh3_jfFhRvzpsvCPkoSCkOf5d1KCz z<8kQ1q%i~@jhi-7u75iG=s`fMn|`IMWe(EFtYo6(QkKavln9}5bM3#Pc0XzZaq5UH zQQJO(hIzZP;-B`OTO6Mkbc^nR2Vk^FS2&2Ue*%~Pz;($)nF9fvS-kt_Eob+v&_?x? z-0v-QS)tOMBb9l{eIp6C(KJ2`Po%4|K8a6;yz~CEE91a)N_M+) zZ(HuwSiXwO!ym=75`xbYwNl9Er3N%c?n{pH)9y$xOWg`Am#L6!AxVA|n|d|j`MT&a zGFV2RizVfyBTEWq97||asku)91bFJUFJ0mv8I^jeR!>VzJ-&qHn#qt^7;I_%)sf-r=BvP&b{gmEP-M>6D4N%7H2PitkdaCMEt)F(4@;pt^Kc4D+?SruNMZdcl;;VKtq9}gD zPJPvg97kWVx&H`cIzj#`vYq=y|NjSN9!(OE+l`cimF-{qNb(R)YGw1pXnG6P&{F%5 zbJ3v#gI@c($WR%6v+jmM-Pq+QAh{CMx%S<=4t|Uk#c5{YuNs%$H5a+VI{Js65Cz?* z+_>17pwX}X9+h9+kdN)TNgg`0m)5^Rl29iIOV?ubeZP#{4ca#{t?iU_?*8(9tUQw` zAV>MA2YP`IFw-;jx`>`3+I{T|2|nuZ3a}<5)|S*M4SU^<*>j||4Tmg zFKGyn(yjgTxAfxgr0&0-iGKse{}%w`GI@4eg97P4D%#W$=zcr?OE1RT?OjV-w2H2} zg$k^vNN?ea&6nNvXEEUQ6fmnk1Zc^JvZU7js#Ap<Q?o7Qn$|eg6}6hazuGc26etaSjlD!Gs?f^Gq>Ytt@T|)F=8O z&FL-2Ad#2RBH89mR_iLLR5(4VbMM~~9AJmJ{ov&4%?HX_ZjYPprq#^UOSg(&3P{%s z%=sQ{SZx(2)qj2JK0nSuN_1>+*Q8wZ{p666Nv+(+-Fa0-)#}wl7Z$es6;B&HvDURQ z7m$DDeEWp7;!DR86$=XSMY#x@$DdOgLcK1mTqv7HPWR(O5o7_Huv u!nMvclB7AG!`%`maXxWReWM9;)1vXC-Yp(=iBO)- -# with symlink build/picoclaw-launcher-tui - -# Or build directly from this directory -go build -o picoclaw-launcher-tui . -``` - -### Key Features - -* 🖥️ Terminal-native interface - works over SSH, on headless servers, and in low-resource environments -* ⚙️ AI model scheme and API key management -* 📱 Communication channel configuration editor (Telegram/Discord/WeChat etc.) -* 🔄 PicoClaw gateway daemon management (start/stop/status monitoring) -* 💬 One-click launch of interactive AI chat session -* 🎯 Keyboard-first design with intuitive shortcuts - -### Other Commands - -```bash -# Run with custom config file path -go run . /path/to/custom/config.json -``` diff --git a/cmd/picoclaw-launcher-tui/config/config.go b/cmd/picoclaw-launcher-tui/config/config.go deleted file mode 100644 index 227b9fa3d..000000000 --- a/cmd/picoclaw-launcher-tui/config/config.go +++ /dev/null @@ -1,236 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -// Package config provides types and I/O for ~/.picoclaw/tui.toml. -package config - -import ( - "bytes" - "encoding/json" - "fmt" - "os" - "path/filepath" - - "github.com/BurntSushi/toml" - - "github.com/sipeed/picoclaw/pkg/fileutil" -) - -// DefaultConfigPath returns the default path to the tui.toml config file. -func DefaultConfigPath() string { - home, err := os.UserHomeDir() - if err != nil { - home = "." - } - return filepath.Join(home, ".picoclaw", "tui.toml") -} - -// TUIConfig is the top-level structure of ~/.picoclaw/tui.toml. -type TUIConfig struct { - Version string `toml:"version"` - Model Model `toml:"model"` - Provider Provider `toml:"provider"` -} - -type Model struct { - Type string `toml:"type"` // "provider" (default) | "manual" -} - -type Provider struct { - Schemes []Scheme `toml:"schemes"` - Users []User `toml:"users"` - Current ProviderCurrent `toml:"current"` -} - -type Scheme struct { - Name string `toml:"name"` // unique key - BaseURL string `toml:"baseURL"` // required - Type string `toml:"type"` // "openai-compatible" (default) | "anthropic" -} - -type User struct { - Name string `toml:"name"` - Scheme string `toml:"scheme"` // references Scheme.Name; (Name+Scheme) is unique - Type string `toml:"type"` // "key" (default) | "OAuth" - Key string `toml:"key"` -} - -type ProviderCurrent struct { - Scheme string `toml:"scheme"` // references Scheme.Name - User string `toml:"user"` // references User.Name where User.Scheme == Scheme - Model string `toml:"model"` // from GET /models -} - -// DefaultConfig returns a minimal valid TUIConfig. -func DefaultConfig() *TUIConfig { - return &TUIConfig{ - Version: "1.0", - Model: Model{Type: "provider"}, - Provider: Provider{ - Schemes: []Scheme{}, - Users: []User{}, - Current: ProviderCurrent{}, - }, - } -} - -// Load reads the TUI config from path. Returns a default config if the file does not exist. -func Load(path string) (*TUIConfig, error) { - data, err := os.ReadFile(path) - if os.IsNotExist(err) { - return DefaultConfig(), nil - } - if err != nil { - return nil, fmt.Errorf("failed to read config file %q: %w", path, err) - } - - cfg := DefaultConfig() - if _, err := toml.Decode(string(data), cfg); err != nil { - return nil, fmt.Errorf("failed to parse config file %q: %w", path, err) - } - - applyDefaults(cfg) - return cfg, nil -} - -// Save writes cfg to path atomically (safe for flash / SD storage). -func Save(path string, cfg *TUIConfig) error { - if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { - return fmt.Errorf("failed to create config directory: %w", err) - } - var buf bytes.Buffer - enc := toml.NewEncoder(&buf) - if err := enc.Encode(cfg); err != nil { - return fmt.Errorf("failed to encode config: %w", err) - } - if err := fileutil.WriteFileAtomic(path, buf.Bytes(), 0o600); err != nil { - return fmt.Errorf("failed to write config file %q: %w", path, err) - } - return nil -} - -func applyDefaults(cfg *TUIConfig) { - if cfg.Version == "" { - cfg.Version = "1.0" - } - if cfg.Model.Type == "" { - cfg.Model.Type = "provider" - } - for i := range cfg.Provider.Schemes { - if cfg.Provider.Schemes[i].Type == "" { - cfg.Provider.Schemes[i].Type = "openai-compatible" - } - } - for i := range cfg.Provider.Users { - if cfg.Provider.Users[i].Type == "" { - cfg.Provider.Users[i].Type = "key" - } - } -} - -// SchemeByName returns the first Scheme whose Name matches, or nil. -func (p *Provider) SchemeByName(name string) *Scheme { - for i := range p.Schemes { - if p.Schemes[i].Name == name { - return &p.Schemes[i] - } - } - return nil -} - -// UsersForScheme returns all users whose Scheme field matches schemeName. -func (p *Provider) UsersForScheme(schemeName string) []User { - var out []User - for _, u := range p.Users { - if u.Scheme == schemeName { - out = append(out, u) - } - } - return out -} - -// SyncSelectedModelToMainConfig syncs the currently selected model to ~/.picoclaw/config.json -// Adds/replaces a "tui-prefer" model entry and sets it as the default model. -// Preserves all other existing fields in the config file unchanged. -func SyncSelectedModelToMainConfig(scheme Scheme, user User, modelID string) error { - home, err := os.UserHomeDir() - if err != nil { - home = "." - } - mainConfigPath := filepath.Join(home, ".picoclaw", "config.json") - - var cfg map[string]any - if data, readErr := os.ReadFile(mainConfigPath); readErr == nil { - if unmarshalErr := json.Unmarshal(data, &cfg); unmarshalErr != nil { - cfg = make(map[string]any) - } - } else { - cfg = make(map[string]any) - } - - if _, ok := cfg["agents"]; !ok { - cfg["agents"] = make(map[string]any) - } - agents, ok := cfg["agents"].(map[string]any) - if ok { - if _, ok := agents["defaults"]; !ok { - agents["defaults"] = make(map[string]any) - } - defaults, ok := agents["defaults"].(map[string]any) - if ok { - defaults["model"] = "tui-prefer" - } - } - - tuiModel := map[string]any{ - "model_name": "tui-prefer", - "model": modelID, - "api_key": user.Key, - "api_base": scheme.BaseURL, - } - - modelList := []any{} - if ml, ok := cfg["model_list"].([]any); ok { - modelList = ml - } - - found := false - for i, m := range modelList { - if entry, ok := m.(map[string]any); ok { - if name, ok := entry["model_name"].(string); ok && name == "tui-prefer" { - modelList[i] = tuiModel - found = true - break - } - } - } - if !found { - modelList = append(modelList, tuiModel) - } - cfg["model_list"] = modelList - - data, err := json.MarshalIndent(cfg, "", " ") - if err != nil { - return err - } - - if err := os.MkdirAll(filepath.Dir(mainConfigPath), 0o700); err != nil { - return err - } - - return os.WriteFile(mainConfigPath, data, 0o600) -} - -func (cfg *TUIConfig) CurrentModelLabel() string { - cur := cfg.Provider.Current - if cur.Model == "" { - return "(not configured)" - } - label := cur.Scheme - if label != "" { - label += " / " - } - return label + cur.Model -} diff --git a/cmd/picoclaw-launcher-tui/main.go b/cmd/picoclaw-launcher-tui/main.go deleted file mode 100644 index 3cb7110c1..000000000 --- a/cmd/picoclaw-launcher-tui/main.go +++ /dev/null @@ -1,48 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package main - -import ( - "fmt" - "os" - "os/exec" - "path/filepath" - - tuicfg "github.com/sipeed/picoclaw/cmd/picoclaw-launcher-tui/config" - "github.com/sipeed/picoclaw/cmd/picoclaw-launcher-tui/ui" -) - -func main() { - configPath := tuicfg.DefaultConfigPath() - if len(os.Args) > 1 { - configPath = os.Args[1] - } - - configDir := filepath.Dir(configPath) - if _, err := os.Stat(configDir); os.IsNotExist(err) { - cmd := exec.Command("picoclaw", "onboard") - cmd.Stdin = os.Stdin - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - _ = cmd.Run() - } - - cfg, err := tuicfg.Load(configPath) - if err != nil { - fmt.Fprintf(os.Stderr, "picoclaw-launcher-tui: %v\n", err) - os.Exit(1) - } - - app := ui.New(cfg, configPath) - // Bind model selection hook to sync to main config - app.OnModelSelected = func(scheme tuicfg.Scheme, user tuicfg.User, modelID string) { - _ = tuicfg.SyncSelectedModelToMainConfig(scheme, user, modelID) - } - if err := app.Run(); err != nil { - fmt.Fprintf(os.Stderr, "picoclaw-launcher-tui: %v\n", err) - os.Exit(1) - } -} diff --git a/cmd/picoclaw-launcher-tui/ui/app.go b/cmd/picoclaw-launcher-tui/ui/app.go deleted file mode 100644 index a65693b01..000000000 --- a/cmd/picoclaw-launcher-tui/ui/app.go +++ /dev/null @@ -1,325 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "fmt" - "sync" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" - - tuicfg "github.com/sipeed/picoclaw/cmd/picoclaw-launcher-tui/config" -) - -// App is the root TUI application. -type App struct { - tapp *tview.Application - pages *tview.Pages - pageStack []string - cfg *tuicfg.TUIConfig - configPath string - pageRefreshFns map[string]func() - headerModelTV *tview.TextView - modalOpen map[string]bool - - // OnModelSelected is called when a model is selected in the UI. - // Can be nil to disable. - OnModelSelected func(scheme tuicfg.Scheme, user tuicfg.User, modelID string) - - modelCache map[string][]modelEntry - modelCacheMu sync.RWMutex - refreshMu sync.Mutex -} - -// cacheKey returns the map key for a (scheme, user) pair. -func cacheKey(schemeName, userName string) string { - return fmt.Sprintf("%s/%s", schemeName, userName) -} - -// cachedModels returns a defensive copy of the cached model list for a user (may be nil). -func (a *App) cachedModels(schemeName, userName string) []modelEntry { - a.modelCacheMu.RLock() - defer a.modelCacheMu.RUnlock() - entries := a.modelCache[cacheKey(schemeName, userName)] - return append([]modelEntry(nil), entries...) -} - -// refreshModelCache fetches models for every user in the config concurrently. -// Serialized by refreshMu so concurrent calls don't race on the cache map. -// When all fetches complete it calls onDone via QueueUpdateDraw. -func (a *App) refreshModelCache(onDone func()) { - go func() { - a.refreshMu.Lock() - defer a.refreshMu.Unlock() - - users := a.cfg.Provider.Users - schemes := a.cfg.Provider.Schemes - - schemeURL := make(map[string]string, len(schemes)) - for _, s := range schemes { - schemeURL[s.Name] = s.BaseURL - } - - var wg sync.WaitGroup - for _, u := range users { - baseURL, ok := schemeURL[u.Scheme] - if !ok || baseURL == "" { - continue - } - if u.Key == "" { - a.modelCacheMu.Lock() - if a.modelCache == nil { - a.modelCache = make(map[string][]modelEntry) - } - a.modelCache[cacheKey(u.Scheme, u.Name)] = nil - a.modelCacheMu.Unlock() - continue - } - wg.Add(1) - bURL := baseURL - go func() { - defer wg.Done() - entries, err := fetchModels(bURL, u.Key) - a.modelCacheMu.Lock() - if a.modelCache == nil { - a.modelCache = make(map[string][]modelEntry) - } - if err != nil || len(entries) == 0 { - a.modelCache[cacheKey(u.Scheme, u.Name)] = nil - } else { - a.modelCache[cacheKey(u.Scheme, u.Name)] = entries - } - a.modelCacheMu.Unlock() - }() - } - wg.Wait() - - if onDone != nil { - a.tapp.QueueUpdateDraw(onDone) - } - }() -} - -// New creates and wires up the TUI application. -func New(cfg *tuicfg.TUIConfig, configPath string) *App { - // Cyberpunk Theme Colors - // Dark background - tview.Styles.PrimitiveBackgroundColor = tcell.NewHexColor(0x050510) // Deep Void - tview.Styles.ContrastBackgroundColor = tcell.NewHexColor(0x1a1a2e) // Dark Indigo - tview.Styles.MoreContrastBackgroundColor = tcell.NewHexColor(0x2a2a40) - - // Borders and Titles - tview.Styles.BorderColor = tcell.NewHexColor(0x00f0ff) // Neon Cyan - tview.Styles.TitleColor = tcell.NewHexColor(0x00f0ff) // Neon Cyan - tview.Styles.GraphicsColor = tcell.NewHexColor(0xff00ff) // Neon Magenta - - // Text - tview.Styles.PrimaryTextColor = tcell.NewHexColor(0xe0e0e0) // Off-white - tview.Styles.SecondaryTextColor = tcell.NewHexColor(0x00f0ff) // Neon Cyan - tview.Styles.TertiaryTextColor = tcell.NewHexColor(0x39ff14) // Neon Lime - tview.Styles.InverseTextColor = tcell.NewHexColor(0x000000) // Black - tview.Styles.ContrastSecondaryTextColor = tcell.NewHexColor(0xff00ff) // Neon Magenta - - a := &App{ - tapp: tview.NewApplication(), - pages: tview.NewPages(), - pageStack: []string{}, - cfg: cfg, - configPath: configPath, - pageRefreshFns: make(map[string]func()), - modalOpen: make(map[string]bool), - } - - a.tapp.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - if event.Key() == tcell.KeyEscape { - if len(a.modalOpen) > 0 { - return event - } - return a.goBack() - } - return event - }) - - a.buildPages() - return a -} - -// Run starts the TUI event loop. -func (a *App) Run() error { - return a.tapp.SetRoot(a.pages, true).EnableMouse(true).Run() -} - -func (a *App) buildPages() { - a.pages.AddPage("home", a.newHomePage(), true, true) - a.pageStack = []string{"home"} -} - -func (a *App) navigateTo(name string, page tview.Primitive) { - a.pages.RemovePage(name) - a.pages.AddPage(name, page, true, false) - a.pageStack = append(a.pageStack, name) - a.pages.SwitchToPage(name) -} - -func (a *App) goBack() *tcell.EventKey { - if len(a.pageStack) <= 1 { - return nil - } - popped := a.pageStack[len(a.pageStack)-1] - a.pageStack = a.pageStack[:len(a.pageStack)-1] - a.pages.RemovePage(popped) - prev := a.pageStack[len(a.pageStack)-1] - if fn, ok := a.pageRefreshFns[prev]; ok { - fn() - } - if prev == "home" && a.headerModelTV != nil { - a.headerModelTV.SetText(a.cfg.CurrentModelLabel() + " ") - } - a.pages.SwitchToPage(prev) - return nil -} - -func (a *App) showModal(name string, primitive tview.Primitive) { - a.modalOpen[name] = true - a.pages.AddPage(name, primitive, true, true) -} - -func (a *App) hideModal(name string) { - delete(a.modalOpen, name) - a.pages.HidePage(name) - a.pages.RemovePage(name) -} - -func (a *App) save() { - if err := tuicfg.Save(a.configPath, a.cfg); err != nil { - a.showError("save failed: " + err.Error()) - } -} - -func (a *App) showError(msg string) { - modal := tview.NewModal(). - SetText(" [red::b]ERROR[-::-]\n\n" + msg). - AddButtons([]string{"OK"}). - SetDoneFunc(func(_ int, _ string) { - a.hideModal("error") - }) - // Cyberpunk Modal Style - modal.SetBackgroundColor(tcell.NewHexColor(0x1a1a2e)) // Deep Indigo - modal.SetTextColor(tcell.NewHexColor(0xffffff)) // White - modal.SetButtonBackgroundColor(tcell.NewHexColor(0xff2a2a)) // Neon Red - modal.SetButtonTextColor(tcell.NewHexColor(0xffffff)) // White - a.showModal("error", modal) -} - -func (a *App) confirmDelete(label string, onConfirm func()) { - modal := tview.NewModal(). - SetText(" [red::b]DELETE WARNING[-::-]\n\nDelete " + label + "?\n[gray]This action cannot be undone.[-]"). - AddButtons([]string{"Delete", "Cancel"}). - SetDoneFunc(func(_ int, buttonLabel string) { - a.hideModal("confirm-delete") - if buttonLabel == "Delete" { - onConfirm() - } - }) - // Cyberpunk Modal Style - modal.SetBackgroundColor(tcell.NewHexColor(0x1a1a2e)) // Deep Indigo - modal.SetTextColor(tcell.NewHexColor(0xffffff)) // White - modal.SetButtonBackgroundColor(tcell.NewHexColor(0xff2a2a)) // Neon Red for danger - modal.SetButtonTextColor(tcell.NewHexColor(0xffffff)) // White - a.showModal("confirm-delete", modal) -} - -func centeredForm(form *tview.Form, widthPct, height int) tview.Primitive { - return tview.NewFlex(). - AddItem(tview.NewBox(), 0, 1, false). - AddItem(tview.NewFlex().SetDirection(tview.FlexRow). - AddItem(tview.NewBox(), 0, 1, false). - AddItem(form, height, 1, true). - AddItem(tview.NewBox(), 0, 1, false), 0, widthPct, true). - AddItem(tview.NewBox(), 0, 1, false) -} - -func hintBar(text string) *tview.TextView { - tv := tview.NewTextView(). - SetText(text). - SetDynamicColors(true). - SetTextAlign(tview.AlignCenter). - SetTextColor(tcell.NewHexColor(0x00f0ff)) // Neon Cyan - tv.SetBackgroundColor(tcell.NewHexColor(0x2a2a40)) // Darker Indigo - return tv -} - -func (a *App) buildShell(pageID string, content tview.Primitive, hint string) tview.Primitive { - var modelTV *tview.TextView - if pageID == "home" { - if a.headerModelTV == nil { - a.headerModelTV = tview.NewTextView() - a.headerModelTV.SetTextAlign(tview.AlignRight). - SetTextColor(tcell.NewHexColor(0x39ff14)). // Neon Lime - SetDynamicColors(true). - SetBackgroundColor(tcell.NewHexColor(0x050510)) - } - modelTV = a.headerModelTV - modelTV.SetText("MODEL: " + a.cfg.CurrentModelLabel() + " ") - } else { - modelTV = tview.NewTextView() - modelTV.SetBackgroundColor(tcell.NewHexColor(0x050510)) - } - - headerLeft := tview.NewTextView(). - SetText(" [#ff00ff::b]///[#00f0ff] PICOCLAW LAUNCHER [#ff00ff]///"). - SetDynamicColors(true). - SetBackgroundColor(tcell.NewHexColor(0x050510)) - - header := tview.NewFlex(). - AddItem(headerLeft, 0, 1, false). - AddItem(modelTV, 0, 1, false) - - sidebar := tview.NewTextView(). - SetDynamicColors(true). - SetWrap(false) - sidebar.SetBackgroundColor(tcell.NewHexColor(0x1a1a2e)) // Deep Indigo - - // Cyberpunk Sidebar Styling - activePrefix := "[#39ff14::b]>> " // Neon Lime arrow - activeSuffix := "[-]" - inactivePrefix := "[#808080] " - inactiveSuffix := "[-]" - - sbText := "\n\n" // Top padding - - menuItem := func(id, label string) string { - if pageID == id { - return activePrefix + label + activeSuffix + "\n\n" - } - return inactivePrefix + label + inactiveSuffix + "\n\n" - } - - sbText += menuItem("home", "HOME") - sbText += menuItem("schemes", "SCHEMES") - sbText += menuItem("users", "USERS") - sbText += menuItem("models", "MODELS") - sbText += menuItem("channels", "CHANNELS") - sbText += menuItem("gateway", "GATEWAY") - - sidebar.SetText(sbText) - - footer := hintBar(hint) - - grid := tview.NewGrid(). - SetRows(1, 0, 1). - SetColumns(20, 0). // Slightly wider sidebar - AddItem(header, 0, 0, 1, 2, 0, 0, false). - AddItem(sidebar, 1, 0, 1, 1, 0, 0, false). - AddItem(content, 1, 1, 1, 1, 0, 0, true). - AddItem(footer, 2, 0, 1, 2, 0, 0, false) - - // Add a border around the content area if possible, or ensure content has its own border - // grid.SetBorders(false) // Grid borders usually look bad, handled by components - - return grid -} diff --git a/cmd/picoclaw-launcher-tui/ui/channels.go b/cmd/picoclaw-launcher-tui/ui/channels.go deleted file mode 100644 index c976f1fcd..000000000 --- a/cmd/picoclaw-launcher-tui/ui/channels.go +++ /dev/null @@ -1,202 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "encoding/json" - "fmt" - "os" - "path/filepath" - "reflect" - "strconv" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" -) - -func (a *App) newChannelsPage() tview.Primitive { - list := tview.NewList() - list.SetBorder(true). - SetTitle(" [#00f0ff::b] COMMUNICATION CHANNELS "). - SetTitleColor(tcell.NewHexColor(0x00f0ff)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - list.SetMainTextColor(tcell.NewHexColor(0xe0e0e0)) - list.SetSecondaryTextColor(tcell.NewHexColor(0x808080)) - list.SetSelectedStyle( - tcell.StyleDefault.Background(tcell.NewHexColor(0xff00ff)).Foreground(tcell.NewHexColor(0x050510)), - ) - list.SetHighlightFullLine(true) - list.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - rebuild := func() { - sel := list.GetCurrentItem() - list.Clear() - - home, err := os.UserHomeDir() - if err != nil { - home = "." - } - configPath := filepath.Join(home, ".picoclaw", "config.json") - - var cfg map[string]any - if data, err := os.ReadFile(configPath); err == nil { - _ = json.Unmarshal(data, &cfg) - } - - if chRaw, ok := cfg["channels"].(map[string]any); ok { - for name, ch := range chRaw { - chMap, ok := ch.(map[string]any) - enabled := "disabled" - if ok { - if e, ok := chMap["enabled"].(bool); ok && e { - enabled = "enabled" - } - } - list.AddItem(name, fmt.Sprintf("Status: %s", enabled), 0, func() { - a.showChannelEditForm(configPath, name, chMap) - }) - } - } - - if sel >= 0 && sel < list.GetItemCount() { - list.SetCurrentItem(sel) - } - } - rebuild() - - a.pageRefreshFns["channels"] = rebuild - - list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - if event.Key() == tcell.KeyEscape { - return a.goBack() - } - return event - }) - - return a.buildShell("channels", list, " [#ff00ff]Enter:[-] edit [#ff2a2a]ESC:[-] back ") -} - -func (a *App) showChannelEditForm(configPath, channelName string, existing map[string]any) { - form := tview.NewForm() - form.SetBorder(true). - SetTitle(" [::b]EDIT CHANNEL "). - SetTitleColor(tcell.NewHexColor(0x39ff14)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - form.SetBackgroundColor(tcell.NewHexColor(0x1a1a2e)) - form.SetFieldBackgroundColor(tcell.NewHexColor(0x050510)) - form.SetFieldTextColor(tcell.NewHexColor(0x00f0ff)) - form.SetLabelColor(tcell.NewHexColor(0xe0e0e0)) - form.SetButtonBackgroundColor(tcell.NewHexColor(0xff00ff)) - form.SetButtonTextColor(tcell.NewHexColor(0xffffff)) - - fields := make(map[string]*tview.InputField) - var nameField *tview.InputField - - if channelName == "" { - nameField = tview.NewInputField(). - SetLabel("Channel Name"). - SetText(""). - SetFieldWidth(28) - form.AddFormItem(nameField) - } - - for k, v := range existing { - if reflect.ValueOf(v).Kind() == reflect.Map || reflect.ValueOf(v).Kind() == reflect.Slice { - continue - } - valStr := fmt.Sprintf("%v", v) - field := tview.NewInputField(). - SetLabel(k). - SetText(valStr). - SetFieldWidth(28) - form.AddFormItem(field) - fields[k] = field - } - - form.AddButton("SAVE", func() { - var cfg map[string]any - if data, err := os.ReadFile(configPath); err == nil { - if err := json.Unmarshal(data, &cfg); err != nil { - cfg = make(map[string]any) - } - } else { - cfg = make(map[string]any) - } - - if _, ok := cfg["channels"]; !ok { - cfg["channels"] = make(map[string]any) - } - channels, ok := cfg["channels"].(map[string]any) - if !ok { - channels = make(map[string]any) - cfg["channels"] = channels - } - - finalName := channelName - if channelName == "" { - if nameField == nil || nameField.GetText() == "" { - a.showError("Channel name is required") - return - } - finalName = nameField.GetText() - } - - updated := make(map[string]any) - if existing != nil { - for k, v := range existing { - updated[k] = v - } - } - for k, field := range fields { - val := field.GetText() - if val == "true" { - updated[k] = true - } else if val == "false" { - updated[k] = false - } else if num, err := strconv.Atoi(val); err == nil { - updated[k] = num - } else { - updated[k] = val - } - } - - if channelName != "" && finalName != channelName { - delete(channels, channelName) - } - channels[finalName] = updated - - data, err := json.MarshalIndent(cfg, "", " ") - if err != nil { - a.showError(fmt.Sprintf("Failed to save config: %v", err)) - return - } - if err := os.MkdirAll(filepath.Dir(configPath), 0o700); err != nil { - a.showError(fmt.Sprintf("Failed to create config directory: %v", err)) - return - } - if err := os.WriteFile(configPath, data, 0o600); err != nil { - a.showError(fmt.Sprintf("Failed to write config: %v", err)) - return - } - - a.hideModal("channel-edit") - a.goBack() - }) - - form.AddButton("CANCEL", func() { - a.hideModal("channel-edit") - }) - - form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - if event.Key() == tcell.KeyEscape { - a.hideModal("channel-edit") - return nil - } - return event - }) - - a.showModal("channel-edit", centeredForm(form, 4, 20)) -} diff --git a/cmd/picoclaw-launcher-tui/ui/gateway.go b/cmd/picoclaw-launcher-tui/ui/gateway.go deleted file mode 100644 index 781204bf2..000000000 --- a/cmd/picoclaw-launcher-tui/ui/gateway.go +++ /dev/null @@ -1,229 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "fmt" - "os/exec" - "runtime" - "strconv" - "strings" - "time" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" - - "github.com/sipeed/picoclaw/pkg/config" - ppid "github.com/sipeed/picoclaw/pkg/pid" -) - -type gatewayStatus struct { - running bool - pid int - version string -} - -func picoHome() string { - return config.GetHome() -} - -func getGatewayStatus() gatewayStatus { - data := ppid.ReadPidFileWithCheck(picoHome()) - if data == nil { - return gatewayStatus{running: false} - } - return gatewayStatus{ - running: true, - pid: data.PID, - version: data.Version, - } -} - -func startGateway() error { - status := getGatewayStatus() - if status.running { - return fmt.Errorf("gateway is already running (PID: %d)", status.pid) - } - - var cmd *exec.Cmd - - if runtime.GOOS == "windows" { - cmd = exec.Command("cmd", "/C", "start /B picoclaw gateway > NUL 2>&1") - } else { - cmd = exec.Command("sh", "-c", "nohup picoclaw gateway > /dev/null 2>&1 &") - } - - err := cmd.Start() - if err != nil { - return err - } - - time.Sleep(1 * time.Second) - - if runtime.GOOS == "windows" { - cmd := exec.Command( - "wmic", - "process", - "where", - "name='picoclaw.exe' and commandline like '%gateway%'", - "get", - "processid", - ) - output, err := cmd.Output() - if err != nil { - return fmt.Errorf("failed to get gateway PID: %w", err) - } - lines := strings.Split(string(output), "\n") - for _, line := range lines[1:] { - line = strings.TrimSpace(line) - if line == "" { - continue - } - _, err := strconv.Atoi(line) - if err == nil { - break - } - } - } - - status = getGatewayStatus() - if !status.running { - return fmt.Errorf("failed to start gateway") - } - return nil -} - -func stopGateway() error { - status := getGatewayStatus() - if !status.running { - return fmt.Errorf("gateway is not running") - } - - var err error - if runtime.GOOS == "windows" { - err = exec.Command("taskkill", "/F", "/PID", strconv.Itoa(status.pid)).Run() - } else { - err = exec.Command("kill", strconv.Itoa(status.pid)).Run() - } - if err != nil { - return err - } - - // Wait for process to stop (ReadPidFileWithCheck cleans up stale pid file) - for i := 0; i < 5; i++ { - if !getGatewayStatus().running { - break - } - time.Sleep(200 * time.Millisecond) - } - - return nil -} - -func (a *App) newGatewayPage() tview.Primitive { - flex := tview.NewFlex().SetDirection(tview.FlexRow) - flex.SetBorder(true). - SetTitle(" [#00f0ff::b] GATEWAY MANAGEMENT "). - SetTitleColor(tcell.NewHexColor(0x00f0ff)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - flex.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - statusTV := tview.NewTextView(). - SetDynamicColors(true). - SetTextAlign(tview.AlignCenter). - SetText("Checking status...") - statusTV.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - var updateStatus func() - - // 使用List作为按钮，保证显示和交互正常 - buttons := tview.NewList() - buttons.SetBackgroundColor(tcell.NewHexColor(0x050510)) - buttons.SetMainTextColor(tcell.ColorWhite) - buttons.SetSelectedBackgroundColor(tcell.NewHexColor(0xff00ff)) - buttons.SetSelectedTextColor(tcell.ColorBlack) - - buttons.AddItem(" [lime]START[white] ", "", 0, func() { - if !getGatewayStatus().running { - err := startGateway() - if err != nil { - a.showError(err.Error()) - } - updateStatus() - } - }) - buttons.AddItem(" [red]STOP[white] ", "", 0, func() { - if getGatewayStatus().running { - err := stopGateway() - if err != nil { - a.showError(err.Error()) - } - updateStatus() - } - }) - - buttonFlex := tview.NewFlex().SetDirection(tview.FlexColumn) - buttonFlex. - AddItem(tview.NewBox(), 0, 1, false). - AddItem(buttons, 20, 1, true). - AddItem(tview.NewBox(), 0, 1, false) - - flex. - AddItem(tview.NewBox(), 0, 1, false). - AddItem(statusTV, 3, 1, false). - AddItem(tview.NewBox(), 0, 1, false). - AddItem(buttonFlex, 4, 1, true). - AddItem(tview.NewBox(), 0, 1, false) - - updateStatus = func() { - status := getGatewayStatus() - if status.running { - versionInfo := "" - if status.version != "" { - versionInfo = fmt.Sprintf("\nVersion: %s", status.version) - } - statusTV.SetText(fmt.Sprintf("[#39ff14::b]GATEWAY RUNNING[-]\n\nPID: %d%s", status.pid, versionInfo)) - buttons.SetItemText(0, " [gray]START[white] ", "") - buttons.SetItemText(1, " [red]STOP[white] ", "") - } else { - statusTV.SetText("[#ff2a2a::b]GATEWAY STOPPED[-]\n\nPID: N/A") - buttons.SetItemText(0, " [lime]START[white] ", "") - buttons.SetItemText(1, " [gray]STOP[white] ", "") - } - } - - updateStatus() - - done := make(chan struct{}) - go func() { - ticker := time.NewTicker(2 * time.Second) - defer ticker.Stop() - for { - select { - case <-ticker.C: - a.tapp.QueueUpdateDraw(updateStatus) - case <-done: - return - } - } - }() - - originalInputCapture := flex.GetInputCapture() - flex.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - if event.Key() == tcell.KeyEscape { - close(done) - return a.goBack() - } - if originalInputCapture != nil { - return originalInputCapture(event) - } - return event - }) - - a.pageRefreshFns["gateway"] = updateStatus - - return a.buildShell("gateway", flex, " [#39ff14]Enter:[-] select [#ff2a2a]ESC:[-] back ") -} diff --git a/cmd/picoclaw-launcher-tui/ui/home.go b/cmd/picoclaw-launcher-tui/ui/home.go deleted file mode 100644 index 74a7769cf..000000000 --- a/cmd/picoclaw-launcher-tui/ui/home.go +++ /dev/null @@ -1,70 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "os" - "os/exec" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" -) - -func (a *App) newHomePage() tview.Primitive { - list := tview.NewList() - list.SetBorder(true). - SetTitle(" [#00f0ff::b] ACTIVE CONFIGURATION "). - SetTitleColor(tcell.NewHexColor(0x00f0ff)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - list.SetMainTextColor(tcell.NewHexColor(0xe0e0e0)) - list.SetSecondaryTextColor(tcell.NewHexColor(0x808080)) - list.SetSelectedStyle( - tcell.StyleDefault.Background(tcell.NewHexColor(0x39ff14)).Foreground(tcell.NewHexColor(0x050510)), - ) - list.SetHighlightFullLine(true) - list.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - rebuildList := func() { - sel := list.GetCurrentItem() - list.Clear() - list.AddItem("MODEL: "+a.cfg.CurrentModelLabel(), "Select to configure AI model", 'm', func() { - a.navigateTo("schemes", a.newSchemesPage()) - }) - list.AddItem( - "CHANNELS: Configure communication channels", - "Manage Telegram/Discord/WeChat channels", - 'n', - func() { - a.navigateTo("channels", a.newChannelsPage()) - }, - ) - list.AddItem("GATEWAY MANAGEMENT", "Manage PicoClaw gateway daemon", 'g', func() { - a.navigateTo("gateway", a.newGatewayPage()) - }) - list.AddItem("CHAT: Start AI agent chat", "Launch interactive chat session", 'c', func() { - a.tapp.Suspend(func() { - cmd := exec.Command("picoclaw", "agent") - cmd.Stdin = os.Stdin - cmd.Stdout = os.Stdout - cmd.Stderr = os.Stderr - _ = cmd.Run() - }) - }) - list.AddItem("QUIT SYSTEM", "Exit PicoClaw Launcher", 'q', func() { a.tapp.Stop() }) - if sel >= 0 && sel < list.GetItemCount() { - list.SetCurrentItem(sel) - } - } - rebuildList() - - a.pageRefreshFns["home"] = rebuildList - - return a.buildShell( - "home", - list, - " [#00f0ff]m:[-] model [#00f0ff]n:[-] channels [#00f0ff]g:[-] gateway [#00f0ff]c:[-] chat [#ff2a2a]q:[-] quit ", - ) -} diff --git a/cmd/picoclaw-launcher-tui/ui/models.go b/cmd/picoclaw-launcher-tui/ui/models.go deleted file mode 100644 index 20e5f0182..000000000 --- a/cmd/picoclaw-launcher-tui/ui/models.go +++ /dev/null @@ -1,200 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "encoding/json" - "fmt" - "io" - "net/http" - "strings" - "time" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" - - tuicfg "github.com/sipeed/picoclaw/cmd/picoclaw-launcher-tui/config" -) - -type modelsAPIResponse struct { - Data []modelEntry `json:"data"` -} - -type modelEntry struct { - ID string `json:"id"` - Name string `json:"name"` - Description string `json:"description"` -} - -func (a *App) newModelsPage(schemeName, userName, baseURL string) tview.Primitive { - table := tview.NewTable(). - SetBorders(false). - SetSelectable(true, false). - SetFixed(0, 0) - table.SetBorder(true). - SetTitle(fmt.Sprintf(" [#00f0ff::b] MODELS · %s / %s ", schemeName, userName)). - SetTitleColor(tcell.NewHexColor(0x00f0ff)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - table.SetSelectedStyle( - tcell.StyleDefault.Background(tcell.NewHexColor(0xff00ff)).Foreground(tcell.NewHexColor(0xffffff)), - ) - table.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - var modelIDs []string - - status := tview.NewTextView(). - SetTextAlign(tview.AlignCenter). - SetDynamicColors(true). - SetText("[#ffff00]FETCHING MODELS...[-]") - status.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - flex := tview.NewFlex(). - SetDirection(tview.FlexRow). - AddItem(status, 1, 0, false). - AddItem(table, 0, 1, false) - - apiKey := a.resolveKey(schemeName, userName) - - go func() { - var entries []modelEntry - var err error - if apiKey == "" { - err = fmt.Errorf("key is required") - } else { - entries, err = fetchModels(baseURL, apiKey) - } - - a.modelCacheMu.Lock() - if a.modelCache == nil { - a.modelCache = make(map[string][]modelEntry) - } - if err == nil && len(entries) > 0 { - a.modelCache[cacheKey(schemeName, userName)] = entries - } else { - a.modelCache[cacheKey(schemeName, userName)] = nil - } - a.modelCacheMu.Unlock() - - a.tapp.QueueUpdateDraw(func() { - if err != nil { - status.SetText(fmt.Sprintf("[#ff2a2a]ERROR: %s[-]", err.Error())) - table.SetCell(0, 0, tview.NewTableCell(" (failed to load models)")) - a.tapp.SetFocus(table) - return - } - if len(entries) == 0 { - status.SetText("[#ff2a2a]NO MODELS RETURNED[-]") - table.SetCell(0, 0, tview.NewTableCell(" (no models available)")) - a.tapp.SetFocus(table) - return - } - - status.SetText(fmt.Sprintf("[#39ff14]%d MODEL(S) LOADED[-]", len(entries))) - for i, m := range entries { - modelIDs = append(modelIDs, m.ID) - table.SetCell(i, 0, - tview.NewTableCell(fmt.Sprintf("%3d", i+1)). - SetAlign(tview.AlignRight). - SetTextColor(tcell.NewHexColor(0x808080)). - SetSelectable(false), - ) - table.SetCell(i, 1, - tview.NewTableCell(" "+m.ID). - SetAlign(tview.AlignLeft). - SetExpansion(1). - SetTextColor(tcell.NewHexColor(0xe0e0e0)), - ) - } - a.tapp.SetFocus(table) - }) - }() - - table.SetSelectedFunc(func(row, _ int) { - if row < 0 || row >= len(modelIDs) { - return - } - a.cfg.Provider.Current = tuicfg.ProviderCurrent{ - Scheme: schemeName, - User: userName, - Model: modelIDs[row], - } - a.save() - - // Trigger model selected callback if set - if a.OnModelSelected != nil && a.cfg.Model.Type == "provider" { - scheme := a.cfg.Provider.SchemeByName(schemeName) - if scheme == nil { - a.goBack() - return - } - var user tuicfg.User - for _, u := range a.cfg.Provider.Users { - if u.Scheme == schemeName && u.Name == userName { - user = u - break - } - } - a.OnModelSelected(*scheme, user, modelIDs[row]) - } - - a.goBack() - }) - - return a.buildShell("models", flex, " [#39ff14]Enter:[-] select [#ff00ff]ESC:[-] back ") -} - -func (a *App) resolveKey(schemeName, userName string) string { - for _, u := range a.cfg.Provider.Users { - if u.Scheme == schemeName && u.Name == userName { - return u.Key - } - } - return "" -} - -func fetchModels(baseURL, apiKey string) ([]modelEntry, error) { - url := strings.TrimRight(baseURL, "/") + "/models" - - client := &http.Client{Timeout: 15 * time.Second} - req, err := http.NewRequest(http.MethodGet, url, nil) - if err != nil { - return nil, fmt.Errorf("build request: %w", err) - } - if apiKey != "" { - req.Header.Set("Authorization", "Bearer "+apiKey) - } - - resp, err := client.Do(req) - if err != nil { - return nil, fmt.Errorf("request failed: %w", err) - } - defer resp.Body.Close() - - if resp.StatusCode != http.StatusOK { - body, _ := io.ReadAll(io.LimitReader(resp.Body, 512)) - return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(body))) - } - - body, err := io.ReadAll(resp.Body) - if err != nil { - return nil, fmt.Errorf("read response: %w", err) - } - - var result modelsAPIResponse - if err := json.Unmarshal(body, &result); err == nil && len(result.Data) > 0 { - return result.Data, nil - } - - var arr []modelEntry - if err := json.Unmarshal(body, &arr); err == nil { - return arr, nil - } - - return nil, fmt.Errorf( - "decode response: unrecognized shape: %s", - strings.TrimSpace(string(body[:min(len(body), 256)])), - ) -} diff --git a/cmd/picoclaw-launcher-tui/ui/schemes.go b/cmd/picoclaw-launcher-tui/ui/schemes.go deleted file mode 100644 index e38d7fa86..000000000 --- a/cmd/picoclaw-launcher-tui/ui/schemes.go +++ /dev/null @@ -1,252 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "fmt" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" - - tuicfg "github.com/sipeed/picoclaw/cmd/picoclaw-launcher-tui/config" -) - -func (a *App) newSchemesPage() tview.Primitive { - table := tview.NewTable(). - SetBorders(false). - SetSelectable(true, false) - table.SetBorder(true). - SetTitle(" [#00f0ff::b] PROVIDER SCHEMES "). - SetTitleColor(tcell.NewHexColor(0x00f0ff)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - table.SetSelectedStyle( - tcell.StyleDefault.Background(tcell.NewHexColor(0xff00ff)).Foreground(tcell.NewHexColor(0xffffff)), - ) - table.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - rowToIdx := func(row int) int { return row / 2 } - - selectedSchemeName := func() string { - row, _ := table.GetSelection() - idx := rowToIdx(row) - schemes := a.cfg.Provider.Schemes - if idx >= 0 && idx < len(schemes) { - return schemes[idx].Name - } - return "" - } - - rebuild := func() { - selName := selectedSchemeName() - table.Clear() - schemes := a.cfg.Provider.Schemes - for i, s := range schemes { - nameRow := i * 2 - detailRow := nameRow + 1 - - table.SetCell(nameRow, 0, - tview.NewTableCell(" "+s.Name). - SetTextColor(tcell.NewHexColor(0xe0e0e0)). - SetExpansion(1). - SetSelectable(true), - ) - - users := a.cfg.Provider.UsersForScheme(s.Name) - n := len(users) - m := 0 - for _, u := range users { - if models := a.cachedModels(s.Name, u.Name); len(models) > 0 { - m++ - } - } - table.SetCell(detailRow, 0, - tview.NewTableCell(fmt.Sprintf(" [#808080](%d/%d) %s", m, n, s.BaseURL)). - SetTextColor(tcell.NewHexColor(0x808080)). - SetExpansion(1). - SetSelectable(false), - ) - table.SetCell(detailRow, 1, - tview.NewTableCell("[#00f0ff]"+s.Type+" "). - SetAlign(tview.AlignRight). - SetSelectable(false), - ) - } - if selName != "" { - for i, s := range schemes { - if s.Name == selName { - table.Select(i*2, 0) - return - } - } - } - if table.GetRowCount() > 0 { - table.Select(0, 0) - } - } - rebuild() - - a.refreshModelCache(rebuild) - a.pageRefreshFns["schemes"] = func() { a.refreshModelCache(rebuild) } - - table.SetSelectedFunc(func(row, _ int) { - idx := rowToIdx(row) - schemes := a.cfg.Provider.Schemes - if idx < 0 || idx >= len(schemes) { - return - } - name := schemes[idx].Name - a.navigateTo("users", a.newUsersPage(name)) - }) - - table.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - row, _ := table.GetSelection() - idx := rowToIdx(row) - schemes := a.cfg.Provider.Schemes - switch event.Rune() { - case 'a': - a.showSchemeForm(nil, func(s tuicfg.Scheme) { - a.cfg.Provider.Schemes = append(a.cfg.Provider.Schemes, s) - a.save() - a.refreshModelCache(rebuild) - }) - return nil - case 'e': - if idx < 0 || idx >= len(schemes) { - return nil - } - origName := schemes[idx].Name - orig := schemes[idx] - a.showSchemeForm(&orig, func(s tuicfg.Scheme) { - current := a.cfg.Provider.Schemes - for i, sc := range current { - if sc.Name == origName { - a.cfg.Provider.Schemes[i] = s - break - } - } - a.save() - a.refreshModelCache(func() { - rebuild() - for i, sc := range a.cfg.Provider.Schemes { - if sc.Name == s.Name { - table.Select(i*2, 0) - break - } - } - }) - }) - return nil - case 'd': - if idx < 0 || idx >= len(schemes) { - return nil - } - name := schemes[idx].Name - a.confirmDelete(fmt.Sprintf("scheme %q", name), func() { - current := a.cfg.Provider.Schemes - newSchemes := make([]tuicfg.Scheme, 0, len(current)) - for _, sc := range current { - if sc.Name != name { - newSchemes = append(newSchemes, sc) - } - } - a.cfg.Provider.Schemes = newSchemes - - existing := a.cfg.Provider.Users - filtered := make([]tuicfg.User, 0, len(existing)) - for _, u := range existing { - if u.Scheme != name { - filtered = append(filtered, u) - } - } - a.cfg.Provider.Users = filtered - - a.save() - a.refreshModelCache(rebuild) - }) - return nil - } - return event - }) - - return a.buildShell( - "schemes", - table, - " [#00f0ff]a:[-] add [#00f0ff]e:[-] edit [#ff2a2a]d:[-] delete [#39ff14]Enter:[-] open [#ff00ff]ESC:[-] back ", - ) -} - -func (a *App) showSchemeForm(existing *tuicfg.Scheme, onSave func(tuicfg.Scheme)) { - name := "" - baseURL := "" - schemeType := "openai-compatible" - title := " ADD SCHEME " - - if existing != nil { - name = existing.Name - baseURL = existing.BaseURL - schemeType = existing.Type - title = " EDIT SCHEME " - } - - typeOptions := []string{"openai-compatible", "anthropic"} - typeIdx := 0 - for i, t := range typeOptions { - if t == schemeType { - typeIdx = i - break - } - } - - form := tview.NewForm() - - form. - AddInputField("Name", name, 20, nil, func(text string) { name = text }). - AddInputField("Base URL", baseURL, 28, nil, func(text string) { baseURL = text }). - AddDropDown("Type", typeOptions, typeIdx, func(option string, _ int) { schemeType = option }). - AddButton("SAVE", func() { - if name == "" { - a.showError("Name is required") - return - } - if baseURL == "" { - a.showError("Base URL is required") - return - } - if existing == nil { - for _, s := range a.cfg.Provider.Schemes { - if s.Name == name { - a.showError(fmt.Sprintf("Scheme name %q already exists", name)) - return - } - } - } - a.hideModal("scheme-form") - onSave(tuicfg.Scheme{Name: name, BaseURL: baseURL, Type: schemeType}) - }). - AddButton("CANCEL", func() { - a.hideModal("scheme-form") - }) - - form.SetBorder(true). - SetTitle(" [::b]" + title + " "). - SetTitleColor(tcell.NewHexColor(0x39ff14)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - form.SetBackgroundColor(tcell.NewHexColor(0x1a1a2e)) - form.SetFieldBackgroundColor(tcell.NewHexColor(0x050510)) - form.SetFieldTextColor(tcell.NewHexColor(0x00f0ff)) - form.SetLabelColor(tcell.NewHexColor(0xe0e0e0)) - form.SetButtonBackgroundColor(tcell.NewHexColor(0xff00ff)) - form.SetButtonTextColor(tcell.NewHexColor(0xffffff)) - form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - if event.Key() == tcell.KeyEscape { - a.hideModal("scheme-form") - return nil - } - return event - }) - - a.showModal("scheme-form", centeredForm(form, 4, 12)) -} diff --git a/cmd/picoclaw-launcher-tui/ui/users.go b/cmd/picoclaw-launcher-tui/ui/users.go deleted file mode 100644 index b00fc8982..000000000 --- a/cmd/picoclaw-launcher-tui/ui/users.go +++ /dev/null @@ -1,261 +0,0 @@ -// PicoClaw - Ultra-lightweight personal AI agent -// License: MIT -// -// Copyright (c) 2026 PicoClaw contributors - -package ui - -import ( - "fmt" - - "github.com/gdamore/tcell/v2" - "github.com/rivo/tview" - - tuicfg "github.com/sipeed/picoclaw/cmd/picoclaw-launcher-tui/config" -) - -func (a *App) newUsersPage(schemeName string) tview.Primitive { - table := tview.NewTable(). - SetBorders(false). - SetSelectable(true, false) - table.SetBorder(true). - SetTitle(fmt.Sprintf(" [#00f0ff::b] USERS · %s ", schemeName)). - SetTitleColor(tcell.NewHexColor(0x00f0ff)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - table.SetSelectedStyle( - tcell.StyleDefault.Background(tcell.NewHexColor(0xff00ff)).Foreground(tcell.NewHexColor(0xffffff)), - ) - table.SetBackgroundColor(tcell.NewHexColor(0x050510)) - - visibleUsers := func() []tuicfg.User { - var out []tuicfg.User - for _, u := range a.cfg.Provider.Users { - if u.Scheme == schemeName { - out = append(out, u) - } - } - return out - } - - findUserGlobalIdx := func(userName string) int { - for i, u := range a.cfg.Provider.Users { - if u.Scheme == schemeName && u.Name == userName { - return i - } - } - return -1 - } - - rowToVisIdx := func(row int) int { return row / 2 } - - selectedUserName := func() string { - row, _ := table.GetSelection() - users := visibleUsers() - visIdx := rowToVisIdx(row) - if visIdx >= 0 && visIdx < len(users) { - return users[visIdx].Name - } - return "" - } - - rebuild := func() { - selName := selectedUserName() - table.Clear() - users := visibleUsers() - for i, u := range users { - nameRow := i * 2 - detailRow := nameRow + 1 - - table.SetCell(nameRow, 0, - tview.NewTableCell(" "+u.Name). - SetTextColor(tcell.NewHexColor(0xe0e0e0)). - SetExpansion(1). - SetSelectable(true), - ) - table.SetCell(nameRow, 1, - tview.NewTableCell(""). - SetSelectable(false), - ) - - models := a.cachedModels(schemeName, u.Name) - var detailText string - if len(models) > 0 { - detailText = fmt.Sprintf(" [#39ff14]%d models available[-]", len(models)) - } else { - detailText = " [#ff2a2a]Inactive / No Access[-]" - } - table.SetCell(detailRow, 0, - tview.NewTableCell(detailText). - SetTextColor(tcell.NewHexColor(0x808080)). - SetExpansion(1). - SetSelectable(false), - ) - table.SetCell(detailRow, 1, - tview.NewTableCell("[#00f0ff]"+u.Type+" "). - SetAlign(tview.AlignRight). - SetSelectable(false), - ) - } - if selName != "" { - for i, u := range users { - if u.Name == selName { - table.Select(i*2, 0) - return - } - } - } - if table.GetRowCount() > 0 { - table.Select(0, 0) - } - } - rebuild() - - a.refreshModelCache(rebuild) - a.pageRefreshFns["users"] = func() { a.refreshModelCache(rebuild) } - - table.SetSelectedFunc(func(row, _ int) { - visIdx := rowToVisIdx(row) - users := visibleUsers() - if visIdx < 0 || visIdx >= len(users) { - return - } - uName := users[visIdx].Name - scheme := a.cfg.Provider.SchemeByName(schemeName) - if scheme == nil { - a.showError(fmt.Sprintf("Scheme %q not found", schemeName)) - return - } - a.navigateTo("models", a.newModelsPage(schemeName, uName, scheme.BaseURL)) - }) - - table.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - row, _ := table.GetSelection() - visIdx := rowToVisIdx(row) - users := visibleUsers() - switch event.Rune() { - case 'a': - a.showUserForm(schemeName, nil, func(u tuicfg.User) { - a.cfg.Provider.Users = append(a.cfg.Provider.Users, u) - a.save() - a.refreshModelCache(rebuild) - }) - return nil - case 'e': - if visIdx < 0 || visIdx >= len(users) { - return nil - } - origName := users[visIdx].Name - orig := a.cfg.Provider.Users[findUserGlobalIdx(origName)] - a.showUserForm(schemeName, &orig, func(u tuicfg.User) { - cfgIdx := findUserGlobalIdx(origName) - if cfgIdx < 0 { - a.showError(fmt.Sprintf("User %q no longer exists", origName)) - return - } - a.cfg.Provider.Users[cfgIdx] = u - a.save() - a.refreshModelCache(func() { - rebuild() - for i, usr := range visibleUsers() { - if usr.Name == u.Name { - table.Select(i*2, 0) - break - } - } - }) - }) - return nil - case 'd': - if visIdx < 0 || visIdx >= len(users) { - return nil - } - uName := users[visIdx].Name - a.confirmDelete(fmt.Sprintf("user %q", uName), func() { - cfgIdx := findUserGlobalIdx(uName) - if cfgIdx < 0 { - return - } - all := a.cfg.Provider.Users - a.cfg.Provider.Users = append(all[:cfgIdx], all[cfgIdx+1:]...) - a.save() - a.refreshModelCache(rebuild) - }) - return nil - } - return event - }) - - return a.buildShell( - "users", - table, - " [#00f0ff]a:[-] add [#00f0ff]e:[-] edit [#ff2a2a]d:[-] delete [#39ff14]Enter:[-] models [#ff00ff]ESC:[-] back ", - ) -} - -func (a *App) showUserForm(schemeName string, existing *tuicfg.User, onSave func(tuicfg.User)) { - name := "" - userType := "key" - key := "" - title := " ADD USER " - - if existing != nil { - name = existing.Name - userType = existing.Type - key = existing.Key - title = " EDIT USER " - } - - typeOptions := []string{"key", "OAuth"} - typeIdx := 0 - for i, t := range typeOptions { - if t == userType { - typeIdx = i - break - } - } - - form := tview.NewForm() - form. - AddInputField("Name", name, 20, nil, func(text string) { name = text }). - AddDropDown("Type", typeOptions, typeIdx, func(option string, _ int) { userType = option }). - AddPasswordField("Key", key, 28, '*', func(text string) { key = text }). - AddButton("SAVE", func() { - if name == "" { - a.showError("Name is required") - return - } - if existing == nil { - for _, u := range a.cfg.Provider.Users { - if u.Scheme == schemeName && u.Name == name { - a.showError(fmt.Sprintf("User name %q already exists for this scheme", name)) - return - } - } - } - a.hideModal("user-form") - onSave(tuicfg.User{Name: name, Scheme: schemeName, Type: userType, Key: key}) - }). - AddButton("CANCEL", func() { - a.hideModal("user-form") - }) - - form.SetBorder(true). - SetTitle(" [::b]" + title + " "). - SetTitleColor(tcell.NewHexColor(0x39ff14)). - SetBorderColor(tcell.NewHexColor(0x00f0ff)) - form.SetBackgroundColor(tcell.NewHexColor(0x1a1a2e)) - form.SetFieldBackgroundColor(tcell.NewHexColor(0x050510)) - form.SetFieldTextColor(tcell.NewHexColor(0x00f0ff)) - form.SetLabelColor(tcell.NewHexColor(0xe0e0e0)) - form.SetButtonBackgroundColor(tcell.NewHexColor(0xff00ff)) - form.SetButtonTextColor(tcell.NewHexColor(0xffffff)) - form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey { - if event.Key() == tcell.KeyEscape { - a.hideModal("user-form") - return nil - } - return event - }) - - a.showModal("user-form", centeredForm(form, 4, 13)) -} diff --git a/cmd/picoclaw/internal/model/add.go b/cmd/picoclaw/internal/model/add.go new file mode 100644 index 000000000..b3ebba340 --- /dev/null +++ b/cmd/picoclaw/internal/model/add.go @@ -0,0 +1,200 @@ +package model + +import ( + "bufio" + "fmt" + "io" + "strconv" + "strings" + + "github.com/spf13/cobra" + + "github.com/sipeed/picoclaw/cmd/picoclaw/internal" + "github.com/sipeed/picoclaw/pkg/config" +) + +const defaultAliasName = "custom-prefer" + +func newAddCommand() *cobra.Command { + var ( + apiBase string + apiKey string + modelID string + alias string + modelType string + ) + + cmd := &cobra.Command{ + Use: "add", + Short: "Add a model from an OpenAI-compatible endpoint", + Long: `Add a model entry by querying an OpenAI-compatible endpoint exposing +GET /models, then setting it as the default model. + +If --model is omitted, the available models are listed and you can pick one +interactively. If --model is provided, the entry is written without contacting +the server. + +Sample interactive session (key shown masked): + + $ picoclaw model add \ + -b https://ark.cn-beijing.volces.com/api/v3 \ + -k 7dff****-****-****-****-********e829 + + 115 model(s) available: + 1) doubao-lite-128k-240428 (doubao-lite-128k) + 2) doubao-pro-128k-240515 (doubao-pro-128k) + ... + 48) deepseek-r1-250120 (deepseek-r1) + 78) kimi-k2-250711 (kimi-k2) + ... + 115) doubao-seed3d-2-0-260328 (doubao-seed3d-2-0) + Pick a model (number or id): 48 + ✓ Saved model 'custom-prefer' (deepseek-r1-250120) and set as default.`, + Example: ` picoclaw model add --api-base https://api.openai.com/v1 --api-key sk-... + picoclaw model add -b http://localhost:8000/v1 -k dummy -m my-model -n local`, + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + return runAdd(addOptions{ + apiBase: strings.TrimSpace(apiBase), + apiKey: strings.TrimSpace(apiKey), + modelID: strings.TrimSpace(modelID), + alias: strings.TrimSpace(alias), + modelType: strings.TrimSpace(modelType), + stdin: cmd.InOrStdin(), + stdout: cmd.OutOrStdout(), + }) + }, + } + + cmd.Flags().StringVarP(&apiBase, "api-base", "b", "", + "API base URL (required), e.g. https://api.openai.com/v1") + cmd.Flags().StringVarP(&apiKey, "api-key", "k", "", "API key (required)") + cmd.Flags().StringVarP(&modelID, "model", "m", "", + "Model id; when set, skips the interactive picker and the network call") + cmd.Flags().StringVarP(&alias, "name", "n", defaultAliasName, + "Local alias written to model_list and used as the default model name") + cmd.Flags().StringVar(&modelType, "type", "openai-compatible", + "Endpoint type (only 'openai-compatible' is supported today)") + _ = cmd.MarkFlagRequired("api-base") + _ = cmd.MarkFlagRequired("api-key") + + return cmd +} + +type addOptions struct { + apiBase string + apiKey string + modelID string + alias string + modelType string + stdin io.Reader + stdout io.Writer +} + +func runAdd(opt addOptions) error { + if opt.modelType != "" && opt.modelType != "openai-compatible" { + return fmt.Errorf("unsupported --type %q (only 'openai-compatible' is supported)", opt.modelType) + } + if opt.alias == "" { + opt.alias = defaultAliasName + } + + selected := opt.modelID + if selected == "" { + entries, err := fetchOpenAIModels(opt.apiBase, opt.apiKey) + if err != nil { + return fmt.Errorf("fetch models: %w", err) + } + if len(entries) == 0 { + return fmt.Errorf("no models returned by %s", opt.apiBase) + } + selected, err = pickModel(opt.stdin, opt.stdout, entries) + if err != nil { + return err + } + } + + return upsertModelDefault(opt.apiBase, opt.apiKey, opt.alias, selected, opt.stdout) +} + +func pickModel(stdin io.Reader, stdout io.Writer, entries []modelEntry) (string, error) { + fmt.Fprintf(stdout, "\n%d model(s) available:\n", len(entries)) + for i, m := range entries { + line := m.ID + if m.Name != "" && m.Name != m.ID { + line = fmt.Sprintf("%s (%s)", m.ID, m.Name) + } + fmt.Fprintf(stdout, " %3d) %s\n", i+1, line) + } + + scanner := bufio.NewScanner(stdin) + for { + fmt.Fprint(stdout, "Pick a model (number or id): ") + if !scanner.Scan() { + if err := scanner.Err(); err != nil { + return "", fmt.Errorf("read input: %w", err) + } + return "", fmt.Errorf("no selection provided") + } + text := strings.TrimSpace(scanner.Text()) + if text == "" { + continue + } + if idx, err := strconv.Atoi(text); err == nil { + if idx < 1 || idx > len(entries) { + fmt.Fprintf(stdout, "Out of range. Enter 1-%d.\n", len(entries)) + continue + } + return entries[idx-1].ID, nil + } + for _, m := range entries { + if m.ID == text { + return m.ID, nil + } + } + fmt.Fprintln(stdout, "Not a valid number or model id; try again.") + } +} + +func upsertModelDefault(apiBase, apiKey, alias, modelID string, stdout io.Writer) error { + configPath := internal.GetConfigPath() + cfg, err := config.LoadConfig(configPath) + if err != nil { + return fmt.Errorf("failed to load config: %w", err) + } + + secureKeys := config.SimpleSecureStrings(apiKey) + + found := false + for _, m := range cfg.ModelList { + if m == nil { + continue + } + if m.ModelName == alias { + m.Model = modelID + m.APIBase = apiBase + m.APIKeys = secureKeys + m.Enabled = true + found = true + break + } + } + if !found { + cfg.ModelList = append(cfg.ModelList, &config.ModelConfig{ + ModelName: alias, + Model: modelID, + APIBase: apiBase, + APIKeys: secureKeys, + Enabled: true, + }) + } + + cfg.Agents.Defaults.ModelName = alias + + if err := config.SaveConfig(configPath, cfg); err != nil { + return fmt.Errorf("failed to save config: %w", err) + } + + fmt.Fprintf(stdout, "✓ Saved model '%s' (%s) and set as default.\n", alias, modelID) + return nil +} diff --git a/cmd/picoclaw/internal/model/add_test.go b/cmd/picoclaw/internal/model/add_test.go new file mode 100644 index 000000000..5da4d5e7f --- /dev/null +++ b/cmd/picoclaw/internal/model/add_test.go @@ -0,0 +1,257 @@ +package model + +import ( + "bytes" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/sipeed/picoclaw/pkg/config" +) + +func TestFetchOpenAIModels_DataEnvelope(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, "/models", r.URL.Path) + assert.Equal(t, "Bearer secret", r.Header.Get("Authorization")) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"data":[{"id":"gpt-foo","name":"Foo"},{"id":"gpt-bar"}]}`)) + })) + defer srv.Close() + + entries, err := fetchOpenAIModels(srv.URL, "secret") + require.NoError(t, err) + require.Len(t, entries, 2) + assert.Equal(t, "gpt-foo", entries[0].ID) + assert.Equal(t, "Foo", entries[0].Name) + assert.Equal(t, "gpt-bar", entries[1].ID) +} + +func TestFetchOpenAIModels_BareArray(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`[{"id":"a"},{"id":"b"}]`)) + })) + defer srv.Close() + + entries, err := fetchOpenAIModels(srv.URL, "secret") + require.NoError(t, err) + require.Len(t, entries, 2) + assert.Equal(t, "a", entries[0].ID) + assert.Equal(t, "b", entries[1].ID) +} + +func TestFetchOpenAIModels_TrimsTrailingSlash(t *testing.T) { + var gotPath string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + _, _ = w.Write([]byte(`{"data":[{"id":"x"}]}`)) + })) + defer srv.Close() + + _, err := fetchOpenAIModels(srv.URL+"/", "k") + require.NoError(t, err) + assert.Equal(t, "/models", gotPath) +} + +func TestFetchOpenAIModels_HTTPError(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + http.Error(w, "nope", http.StatusUnauthorized) + })) + defer srv.Close() + + _, err := fetchOpenAIModels(srv.URL, "bad") + require.Error(t, err) + assert.Contains(t, err.Error(), "HTTP 401") +} + +func TestFetchOpenAIModels_EmptyDataEnvelope(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + _, _ = w.Write([]byte(`{"data":[]}`)) + })) + defer srv.Close() + + entries, err := fetchOpenAIModels(srv.URL, "k") + require.NoError(t, err) + assert.Empty(t, entries) +} + +func TestFetchOpenAIModels_EmptyBareArray(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + _, _ = w.Write([]byte(`[]`)) + })) + defer srv.Close() + + entries, err := fetchOpenAIModels(srv.URL, "k") + require.NoError(t, err) + assert.Empty(t, entries) +} + +func TestFetchOpenAIModels_UnrecognizedShape(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + _, _ = w.Write([]byte(`{"models":"not-supported"}`)) + })) + defer srv.Close() + + _, err := fetchOpenAIModels(srv.URL, "k") + require.Error(t, err) + assert.Contains(t, err.Error(), "unrecognized shape") +} + +func TestFetchOpenAIModels_RequiresInputs(t *testing.T) { + _, err := fetchOpenAIModels("", "k") + require.Error(t, err) + assert.Contains(t, err.Error(), "api base") + + _, err = fetchOpenAIModels("https://example.com", "") + require.Error(t, err) + assert.Contains(t, err.Error(), "api key") +} + +func TestPickModel_ByIndex(t *testing.T) { + entries := []modelEntry{{ID: "a"}, {ID: "b"}, {ID: "c"}} + out := &bytes.Buffer{} + got, err := pickModel(strings.NewReader("2\n"), out, entries) + require.NoError(t, err) + assert.Equal(t, "b", got) + assert.Contains(t, out.String(), "3 model(s) available") +} + +func TestPickModel_ByID(t *testing.T) { + entries := []modelEntry{{ID: "alpha"}, {ID: "beta"}} + out := &bytes.Buffer{} + got, err := pickModel(strings.NewReader("beta\n"), out, entries) + require.NoError(t, err) + assert.Equal(t, "beta", got) +} + +func TestPickModel_RetriesOnInvalid(t *testing.T) { + entries := []modelEntry{{ID: "x"}} + out := &bytes.Buffer{} + got, err := pickModel(strings.NewReader("\n9\nnot-a-model\nx\n"), out, entries) + require.NoError(t, err) + assert.Equal(t, "x", got) + rendered := out.String() + assert.Contains(t, rendered, "Out of range") + assert.Contains(t, rendered, "Not a valid number") +} + +func TestRunAdd_WithExplicitModel_NoNetwork(t *testing.T) { + initTest(t) + + out := &bytes.Buffer{} + err := runAdd(addOptions{ + apiBase: "https://invalid.invalid/v1", + apiKey: "k", + modelID: "explicit-model", + alias: "myalias", + modelType: "openai-compatible", + stdout: out, + }) + require.NoError(t, err) + assert.Contains(t, out.String(), "Saved model 'myalias' (explicit-model)") + + cfg, err := config.LoadConfig(configPath) + require.NoError(t, err) + assert.Equal(t, "myalias", cfg.Agents.Defaults.GetModelName()) + added := findModelByName(cfg, "myalias") + require.NotNil(t, added, "expected model 'myalias' in model_list") + assert.Equal(t, "explicit-model", added.Model) + assert.Equal(t, "https://invalid.invalid/v1", added.APIBase) + assert.True(t, added.Enabled) + require.Len(t, added.APIKeys, 1) + assert.Equal(t, "k", added.APIKeys[0].String()) +} + +func findModelByName(cfg *config.Config, name string) *config.ModelConfig { + for _, m := range cfg.ModelList { + if m != nil && m.ModelName == name { + return m + } + } + return nil +} + +func TestRunAdd_FetchAndPick(t *testing.T) { + initTest(t) + + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, "Bearer my-key", r.Header.Get("Authorization")) + _, _ = w.Write([]byte(`{"data":[{"id":"m1"},{"id":"m2"}]}`)) + })) + defer srv.Close() + + out := &bytes.Buffer{} + err := runAdd(addOptions{ + apiBase: srv.URL, + apiKey: "my-key", + alias: defaultAliasName, + modelType: "openai-compatible", + stdin: strings.NewReader("2\n"), + stdout: out, + }) + require.NoError(t, err) + + cfg, err := config.LoadConfig(configPath) + require.NoError(t, err) + assert.Equal(t, defaultAliasName, cfg.Agents.Defaults.GetModelName()) + added := findModelByName(cfg, defaultAliasName) + require.NotNil(t, added) + assert.Equal(t, "m2", added.Model) +} + +func TestRunAdd_UpsertsExistingAlias(t *testing.T) { + initTest(t) + + first := &bytes.Buffer{} + require.NoError(t, runAdd(addOptions{ + apiBase: "https://a.example/v1", + apiKey: "k1", + modelID: "m1", + alias: "shared", + stdout: first, + })) + + second := &bytes.Buffer{} + require.NoError(t, runAdd(addOptions{ + apiBase: "https://b.example/v1", + apiKey: "k2", + modelID: "m2", + alias: "shared", + stdout: second, + })) + + cfg, err := config.LoadConfig(configPath) + require.NoError(t, err) + matches := 0 + for _, m := range cfg.ModelList { + if m != nil && m.ModelName == "shared" { + matches++ + } + } + assert.Equal(t, 1, matches, "alias should be updated, not duplicated") + + updated := findModelByName(cfg, "shared") + require.NotNil(t, updated) + assert.Equal(t, "m2", updated.Model) + assert.Equal(t, "https://b.example/v1", updated.APIBase) + assert.Equal(t, "k2", updated.APIKeys[0].String()) +} + +func TestRunAdd_RejectsUnsupportedType(t *testing.T) { + initTest(t) + + err := runAdd(addOptions{ + apiBase: "https://x/v1", + apiKey: "k", + modelID: "m", + alias: "a", + modelType: "anthropic", + stdout: &bytes.Buffer{}, + }) + require.Error(t, err) + assert.Contains(t, err.Error(), "unsupported --type") +} diff --git a/cmd/picoclaw/internal/model/command.go b/cmd/picoclaw/internal/model/command.go index 330734b82..c412993a0 100644 --- a/cmd/picoclaw/internal/model/command.go +++ b/cmd/picoclaw/internal/model/command.go @@ -21,11 +21,17 @@ func NewModelCommand() *cobra.Command { If no argument is provided, shows the current default model. If a model name is provided, sets it as the default model. +To onboard a model from a custom OpenAI-compatible endpoint (fetch the +available list online and pick one), use the 'add' subcommand: + + picoclaw model add --help + Examples: picoclaw model # Show current default model picoclaw model gpt-5.2 # Set gpt-5.2 as default picoclaw model claude-sonnet-4.6 # Set claude-sonnet-4.6 as default picoclaw model local-model # Set local VLLM server as default + picoclaw model add -b URL -k KEY # Add a model from a custom endpoint Note: 'local-model' is a special value for using a local VLLM server (running at localhost:8000 by default) which does not require an API key.`, @@ -51,6 +57,8 @@ Note: 'local-model' is a special value for using a local VLLM server }, } + cmd.AddCommand(newAddCommand()) + return cmd } @@ -66,6 +74,9 @@ func showCurrentModel(cfg *config.Config) { fmt.Println("\nAvailable models in your config:") listAvailableModels(cfg) } + + fmt.Println("\nTip: 'picoclaw model add -b URL -k KEY' adds a model from a custom") + fmt.Println(" OpenAI-compatible endpoint (see 'picoclaw model add --help').") } func listAvailableModels(cfg *config.Config) { diff --git a/cmd/picoclaw/internal/model/online.go b/cmd/picoclaw/internal/model/online.go new file mode 100644 index 000000000..9b8f7811d --- /dev/null +++ b/cmd/picoclaw/internal/model/online.go @@ -0,0 +1,77 @@ +package model + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + "time" +) + +type modelEntry struct { + ID string `json:"id"` + Name string `json:"name"` + Description string `json:"description"` +} + +type modelsAPIResponse struct { + Data []modelEntry `json:"data"` +} + +// fetchOpenAIModels GETs /models with Bearer auth and accepts both the +// {data:[…]} envelope and a bare array shape used by various OpenAI-compatible servers. +func fetchOpenAIModels(baseURL, apiKey string) ([]modelEntry, error) { + if strings.TrimSpace(baseURL) == "" { + return nil, fmt.Errorf("api base is required") + } + if strings.TrimSpace(apiKey) == "" { + return nil, fmt.Errorf("api key is required") + } + + url := strings.TrimRight(baseURL, "/") + "/models" + + client := &http.Client{Timeout: 15 * time.Second} + req, err := http.NewRequest(http.MethodGet, url, nil) + if err != nil { + return nil, fmt.Errorf("build request: %w", err) + } + req.Header.Set("Authorization", "Bearer "+apiKey) + + resp, err := client.Do(req) + if err != nil { + return nil, fmt.Errorf("request failed: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + body, _ := io.ReadAll(io.LimitReader(resp.Body, 512)) + return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(body))) + } + + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("read response: %w", err) + } + + // {"data": [...]} envelope. Distinguish "envelope shape with empty list" + // from "object without a data key" via Data being non-nil after unmarshal: + // json.Unmarshal sets Data to []modelEntry{} for `{"data":[]}` but leaves + // it as nil when "data" is absent or null. + var envelope modelsAPIResponse + if err := json.Unmarshal(body, &envelope); err == nil && envelope.Data != nil { + return envelope.Data, nil + } + + // Bare-array shape, including `[]`. + var arr []modelEntry + if err := json.Unmarshal(body, &arr); err == nil { + return arr, nil + } + + preview := body + if len(preview) > 256 { + preview = preview[:256] + } + return nil, fmt.Errorf("decode response: unrecognized shape: %s", strings.TrimSpace(string(preview))) +} diff --git a/docker/Dockerfile.goreleaser.launcher b/docker/Dockerfile.goreleaser.launcher index 0a20a90b3..97944afc1 100644 --- a/docker/Dockerfile.goreleaser.launcher +++ b/docker/Dockerfile.goreleaser.launcher @@ -6,7 +6,6 @@ RUN apk add --no-cache ca-certificates tzdata COPY $TARGETPLATFORM/picoclaw /usr/local/bin/picoclaw COPY $TARGETPLATFORM/picoclaw-launcher /usr/local/bin/picoclaw-launcher -COPY $TARGETPLATFORM/picoclaw-launcher-tui /usr/local/bin/picoclaw-launcher-tui ENTRYPOINT ["picoclaw-launcher"] CMD ["-console", "-public", "-no-browser"] diff --git a/docs/guides/docker.fr.md b/docs/guides/docker.fr.md index ed0d14cf3..e174298ac 100644 --- a/docs/guides/docker.fr.md +++ b/docs/guides/docker.fr.md @@ -36,7 +36,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Mode Launcher (Console Web) -L'image `launcher` inclut les trois binaires (`picoclaw`, `picoclaw-launcher`, `picoclaw-launcher-tui`) et démarre la console web par défaut, qui fournit une interface navigateur pour la configuration et le chat. +L'image `launcher` inclut les deux binaires (`picoclaw`, `picoclaw-launcher`) et démarre la console web par défaut, qui fournit une interface navigateur pour la configuration et le chat. ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/guides/docker.ja.md b/docs/guides/docker.ja.md index 8fa5ae60c..19199aaac 100644 --- a/docs/guides/docker.ja.md +++ b/docs/guides/docker.ja.md @@ -36,7 +36,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Launcher モード (Web コンソール) -`launcher` イメージには 3 つのバイナリ（`picoclaw`、`picoclaw-launcher`、`picoclaw-launcher-tui`）がすべて含まれており、デフォルトで Web コンソールを起動します。ブラウザベースの設定・チャット画面を提供します。 +`launcher` イメージには 2 つのバイナリ（`picoclaw`、`picoclaw-launcher`）が含まれており、デフォルトで Web コンソールを起動します。ブラウザベースの設定・チャット画面を提供します。 ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/guides/docker.md b/docs/guides/docker.md index e017538f7..e2e472fbf 100644 --- a/docs/guides/docker.md +++ b/docs/guides/docker.md @@ -39,7 +39,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Launcher Mode (Web Console) -The `launcher` image includes all three binaries (`picoclaw`, `picoclaw-launcher`, `picoclaw-launcher-tui`) and starts the web console by default, which provides a browser-based UI for configuration and chat. +The `launcher` image includes both binaries (`picoclaw`, `picoclaw-launcher`) and starts the web console by default, which provides a browser-based UI for configuration and chat. ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/guides/docker.ms.md b/docs/guides/docker.ms.md index 7adab6759..5a426cb99 100644 --- a/docs/guides/docker.ms.md +++ b/docs/guides/docker.ms.md @@ -35,7 +35,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Mod Launcher (Konsol Web) -Imej `launcher` merangkumi ketiga-tiga binari (`picoclaw`, `picoclaw-launcher`, `picoclaw-launcher-tui`) dan memulakan konsol web secara lalai, yang menyediakan UI berasaskan pelayar untuk konfigurasi dan sembang. +Imej `launcher` merangkumi kedua-dua binari (`picoclaw`, `picoclaw-launcher`) dan memulakan konsol web secara lalai, yang menyediakan UI berasaskan pelayar untuk konfigurasi dan sembang. ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/guides/docker.pt-br.md b/docs/guides/docker.pt-br.md index d7d55e753..ab71af8e6 100644 --- a/docs/guides/docker.pt-br.md +++ b/docs/guides/docker.pt-br.md @@ -36,7 +36,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Modo Launcher (Console Web) -A imagem `launcher` inclui os três binários (`picoclaw`, `picoclaw-launcher`, `picoclaw-launcher-tui`) e inicia o console web por padrão, que fornece uma interface baseada em navegador para configuração e chat. +A imagem `launcher` inclui ambos os binários (`picoclaw`, `picoclaw-launcher`) e inicia o console web por padrão, que fornece uma interface baseada em navegador para configuração e chat. ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/guides/docker.vi.md b/docs/guides/docker.vi.md index 05f1b3d68..e91450bb0 100644 --- a/docs/guides/docker.vi.md +++ b/docs/guides/docker.vi.md @@ -36,7 +36,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Chế Độ Launcher (Web Console) -Image `launcher` bao gồm cả ba binary (`picoclaw`, `picoclaw-launcher`, `picoclaw-launcher-tui`) và khởi động web console mặc định, cung cấp giao diện trình duyệt để cấu hình và chat. +Image `launcher` bao gồm cả hai binary (`picoclaw`, `picoclaw-launcher`) và khởi động web console mặc định, cung cấp giao diện trình duyệt để cấu hình và chat. ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/guides/docker.zh.md b/docs/guides/docker.zh.md index bed445751..855375d9c 100644 --- a/docs/guides/docker.zh.md +++ b/docs/guides/docker.zh.md @@ -36,7 +36,7 @@ docker compose -f docker/docker-compose.yml --profile gateway down ### Launcher 模式 (Web 控制台) -`launcher` 镜像包含所有三个二进制文件（`picoclaw`、`picoclaw-launcher`、`picoclaw-launcher-tui`），默认启动 Web 控制台，提供基于浏览器的配置和聊天界面。 +`launcher` 镜像包含两个二进制文件（`picoclaw`、`picoclaw-launcher`），默认启动 Web 控制台，提供基于浏览器的配置和聊天界面。 ```bash docker compose -f docker/docker-compose.yml --profile launcher up -d diff --git a/docs/project/README.fr.md b/docs/project/README.fr.md index 1e2f59bee..b02067d2a 100644 --- a/docs/project/README.fr.md +++ b/docs/project/README.fr.md @@ -292,24 +292,6 @@ Après cette étape unique, `picoclaw-launcher` s'ouvrira normalement lors des l -### 💻 TUI Launcher (Recommandé pour les environnements sans interface / SSH) - -Le TUI (Terminal UI) Launcher fournit une interface terminal complète pour la configuration et la gestion. Idéal pour les serveurs, Raspberry Pi et autres environnements sans interface graphique. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**Pour commencer :** - -Utilisez les menus TUI pour : **1)** Configurer un Provider -> **2)** Configurer un Channel -> **3)** Démarrer le Gateway -> **4)** Chattez ! - -Pour la documentation détaillée du TUI, voir [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android diff --git a/docs/project/README.id.md b/docs/project/README.id.md index 244e6e49a..49c64e74c 100644 --- a/docs/project/README.id.md +++ b/docs/project/README.id.md @@ -289,24 +289,6 @@ Setelah langkah satu kali ini, `picoclaw-launcher` akan terbuka secara normal pa -### 💻 TUI Launcher (Direkomendasikan untuk Headless / SSH) - -TUI (Terminal UI) Launcher menyediakan antarmuka terminal lengkap untuk konfigurasi dan manajemen. Ideal untuk server, Raspberry Pi, dan lingkungan headless lainnya. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**Memulai:** - -Gunakan menu TUI untuk: **1)** Konfigurasi Provider -> **2)** Konfigurasi Channel -> **3)** Mulai Gateway -> **4)** Chat! - -Untuk dokumentasi TUI lengkap, lihat [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android Berikan kehidupan kedua untuk ponsel lama Anda! Ubah menjadi Asisten AI pintar dengan PicoClaw. diff --git a/docs/project/README.it.md b/docs/project/README.it.md index b3db6fece..0cf6cf8db 100644 --- a/docs/project/README.it.md +++ b/docs/project/README.it.md @@ -289,24 +289,6 @@ Dopo questo passaggio una tantum, `picoclaw-launcher` si aprirà normalmente ai -### 💻 TUI Launcher (Consigliato per Headless / SSH) - -Il TUI (Terminal UI) Launcher fornisce un'interfaccia terminale completa per la configurazione e la gestione. Ideale per server, Raspberry Pi e altri ambienti headless. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**Per iniziare:** - -Usa i menu TUI per: **1)** Configurare un Provider -> **2)** Configurare un Channel -> **3)** Avviare il Gateway -> **4)** Chattare! - -Per la documentazione dettagliata del TUI, vedi [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android Dai una seconda vita al tuo telefono di dieci anni fa! Trasformalo in un assistente IA intelligente con PicoClaw. diff --git a/docs/project/README.ja.md b/docs/project/README.ja.md index 66d06ba5e..6e3060688 100644 --- a/docs/project/README.ja.md +++ b/docs/project/README.ja.md @@ -289,24 +289,6 @@ docker compose -f docker/docker-compose.yml --profile launcher up -d -### 💻 TUI Launcher（ヘッドレス / SSH 向け推奨） - -TUI（Terminal UI）Launcher は設定と管理のためのフル機能ターミナルインターフェースを提供します。サーバー、Raspberry Pi、その他のヘッドレス環境に最適です。 - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**始め方:** - -TUI メニューを使って：**1)** Provider を設定 → **2)** Channel を設定 → **3)** Gateway を起動 → **4)** チャット！ - -TUI の詳細なドキュメントは [docs.picoclaw.io](https://docs.picoclaw.io) を参照してください。 - ### 📱 Android diff --git a/docs/project/README.ko.md b/docs/project/README.ko.md index cfc985688..dfefa67fe 100644 --- a/docs/project/README.ko.md +++ b/docs/project/README.ko.md @@ -289,24 +289,6 @@ macOS에서는 인터넷에서 다운로드한 앱이고 Mac App Store 공증을 -### 💻 TUI Launcher (헤드리스 / SSH 권장) - -TUI(Terminal UI) Launcher는 설정과 관리를 위한 모든 기능을 갖춘 터미널 인터페이스를 제공합니다. 서버, Raspberry Pi, 기타 헤드리스 환경에 적합합니다. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**시작 방법:** - -TUI 메뉴를 사용해 다음 순서로 진행하세요. **1)** 프로바이더 설정 -> **2)** 채널 설정 -> **3)** 게이트웨이 시작 -> **4)** 채팅! - -자세한 TUI 문서는 [docs.picoclaw.io](https://docs.picoclaw.io)를 참고하세요. - ### 📱 Android 오래된 스마트폰에 새 생명을 불어넣어 보세요! PicoClaw를 설치하면 스마트 AI 어시스턴트로 바꿀 수 있습니다. diff --git a/docs/project/README.ms.md b/docs/project/README.ms.md index f8c9e95e7..73c428f11 100644 --- a/docs/project/README.ms.md +++ b/docs/project/README.ms.md @@ -286,24 +286,6 @@ Selepas langkah sekali ini, `picoclaw-launcher` akan dibuka secara normal pada p -### 💻 Pelancar TUI (Disyorkan untuk Headless / SSH) - -Pelancar TUI menyediakan antara muka terminal lengkap untuk konfigurasi dan pengurusan. Sesuai untuk pelayan, Raspberry Pi, dan persekitaran tanpa kepala lain. - -```bash -picoclaw-launcher-tui -``` - -

-Pelancar TUI -

- -**Memulakan:** - -Gunakan menu TUI untuk: **1)** Konfigurasikan Penyedia -> **2)** Konfigurasikan Saluran -> **3)** Mulakan Gateway -> **4)** Sembang! - -Untuk dokumentasi TUI terperinci, lihat [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android Berikan telefon lama anda kehidupan baru! Jadikannya Pembantu AI pintar dengan PicoClaw. diff --git a/docs/project/README.pt-br.md b/docs/project/README.pt-br.md index 56d4ddd63..74cb967de 100644 --- a/docs/project/README.pt-br.md +++ b/docs/project/README.pt-br.md @@ -289,24 +289,6 @@ Após esta etapa única, o `picoclaw-launcher` abrirá normalmente nos lançamen -### 💻 TUI Launcher (Recomendado para Headless / SSH) - -O TUI (Terminal UI) Launcher fornece uma interface de terminal completa para configuração e gerenciamento. Ideal para servidores, Raspberry Pi e outros ambientes headless. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**Primeiros passos:** - -Use os menus do TUI para: **1)** Configurar um Provider -> **2)** Configurar um Channel -> **3)** Iniciar o Gateway -> **4)** Conversar! - -Para documentação detalhada do TUI, veja [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android diff --git a/docs/project/README.vi.md b/docs/project/README.vi.md index 52a56796b..743069021 100644 --- a/docs/project/README.vi.md +++ b/docs/project/README.vi.md @@ -289,24 +289,6 @@ Sau bước này, `picoclaw-launcher` sẽ mở bình thường trong các lần -### 💻 TUI Launcher (Khuyến nghị cho Headless / SSH) - -TUI (Terminal UI) Launcher cung cấp giao diện terminal đầy đủ tính năng để cấu hình và quản lý. Lý tưởng cho máy chủ, Raspberry Pi và các môi trường headless khác. - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**Bắt đầu:** - -Sử dụng menu TUI để: **1)** Cấu hình Provider -> **2)** Cấu hình Channel -> **3)** Khởi động Gateway -> **4)** Trò chuyện! - -Để biết tài liệu TUI chi tiết, xem [docs.picoclaw.io](https://docs.picoclaw.io). - ### 📱 Android diff --git a/docs/project/README.zh.md b/docs/project/README.zh.md index a4fc892bd..253bb84ed 100644 --- a/docs/project/README.zh.md +++ b/docs/project/README.zh.md @@ -289,24 +289,6 @@ macOS 可能会在首次启动时拦截 `picoclaw-launcher`，因为它从互联 -### 💻 TUI Launcher（推荐无头环境 / SSH） - -TUI（终端 UI）Launcher 提供功能完整的终端配置与管理界面，适合服务器、树莓派等无显示器环境。 - -```bash -picoclaw-launcher-tui -``` - -

-TUI Launcher -

- -**开始使用：** - -通过 TUI 菜单：**1)** 配置 Provider -> **2)** 配置 Channel -> **3)** 启动 Gateway -> **4)** 开始聊天！ - -详细 TUI 文档请参阅 [docs.picoclaw.io](https://docs.picoclaw.io)。 - ### 📱 Android diff --git a/go.mod b/go.mod index 4afbe9d85..c7e77c0f9 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,6 @@ go 1.25.9 require ( fyne.io/systray v1.12.0 - github.com/BurntSushi/toml v1.6.0 github.com/SevereCloud/vksdk/v3 v3.3.1 github.com/adhocore/gronx v1.19.6 github.com/anthropics/anthropic-sdk-go v1.26.0 @@ -18,7 +17,6 @@ require ( github.com/creack/pty v1.1.24 github.com/ergochat/irc-go v0.6.0 github.com/ergochat/readline v0.1.3 - github.com/gdamore/tcell/v2 v2.13.8 github.com/gomarkdown/markdown v0.0.0-20260411013819-759bbc3e3207 github.com/google/uuid v1.6.0 github.com/gorilla/websocket v1.5.3 @@ -33,7 +31,6 @@ require ( github.com/openai/openai-go/v3 v3.22.0 github.com/pion/rtp v1.10.1 github.com/pion/webrtc/v3 v3.3.6 - github.com/rivo/tview v0.42.0 github.com/rs/zerolog v1.35.1 github.com/slack-go/slack v0.17.3 github.com/spf13/cobra v1.10.2 @@ -79,7 +76,6 @@ require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/elliotchance/orderedmap/v3 v3.1.0 // indirect - github.com/gdamore/encoding v1.0.1 // indirect github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/godbus/dbus/v5 v5.1.0 // indirect @@ -122,7 +118,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/go.sum b/go.sum index 19547816d..5cd39ec8d 100644 --- a/go.sum +++ b/go.sum @@ -5,8 +5,6 @@ filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= fyne.io/systray v1.12.0 h1:CA1Kk0e2zwFlxtc02L3QFSiIbxJ/P0n582YrZHT7aTM= fyne.io/systray v1.12.0/go.mod h1:RVwqP9nYMo7h5zViCBHri2FgjXF7H2cub7MAq4NSoLs= -github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= -github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU= github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= github.com/SevereCloud/vksdk/v3 v3.3.1 h1:O86zsp5LQnHE+O5acvuXM/s6S1LyxzVTkF6+Lup0Jyg= @@ -105,10 +103,6 @@ github.com/ergochat/readline v0.1.3 h1:/DytGTmwdUJcLAe3k3VJgowh5vNnsdifYT6uVaf4p github.com/ergochat/readline v0.1.3/go.mod h1:o3ux9QLHLm77bq7hDB21UTm6HlV2++IPDMfIfKDuOgY= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= -github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw= -github.com/gdamore/encoding v1.0.1/go.mod h1:0Z0cMFinngz9kS1QfMjCP8TY7em3bZYeeklsSDPivEo= -github.com/gdamore/tcell/v2 v2.13.8 h1:Mys/Kl5wfC/GcC5Cx4C2BIQH9dbnhnkPgS9/wF3RlfU= -github.com/gdamore/tcell/v2 v2.13.8/go.mod h1:+Wfe208WDdB7INEtCsNrAN6O2m+wsTPk1RAovjaILlo= github.com/github/copilot-sdk/go v0.2.0 h1:RnrIIirmtp4wGgqSQFJ2k9phbeveIxOtYZqDogoNEa0= github.com/github/copilot-sdk/go v0.2.0/go.mod h1:uGWkjVYcp2DV9DgtqYihh5tEoJjNqxIFaUNnrwY4FxM= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= @@ -232,8 +226,6 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= -github.com/rivo/tview v0.42.0 h1:b/ftp+RxtDsHSaynXTbJb+/n/BxDEi+W3UfF5jILK6c= -github.com/rivo/tview v0.42.0/go.mod h1:cSfIYfhpSGCjp3r/ECJb+GKS7cGJnqV8vfjQPwoXyfY= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= From 1722cfc28222f5259a717a52aaeb63b0a44c1a5c Mon Sep 17 00:00:00 2001 From: LiusCraft Date: Thu, 30 Apr 2026 02:24:29 +0800 Subject: [PATCH 62/87] 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 cb1e1a3595248faefd4275c528ec4d67d125c80c Mon Sep 17 00:00:00 2001 From: Guoguo <16666742+imguoguo@users.noreply.github.com> Date: Thu, 30 Apr 2026 11:08:00 +0800 Subject: [PATCH 63/87] fix(feishu): fix image download with API fallback and post image support (#2708) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(feishu): fix image download with API fallback and post image support - Add Image.Get API fallback when MessageResource.Get fails (different permission scope: im:resource vs im:message:readonly) - Extract and download images from post (rich text) messages - Extract images from interactive card messages - Deduplicate post image keys across locales - Add comprehensive tests for new helpers Co-Authored-By: Claude Opus 4.6 * feat(media): add image path tags alongside base64 for LLM file access Images are still base64-encoded into msg.Media for multimodal LLMs, but now also get [image:path] tags injected into message content so the LLM knows the local file path for save/forward operations. Co-Authored-By: Claude Opus 4.6 * refactor(media): only auto-inject images for tool results, not user messages Channel-received images (role=user) now get path tags only, letting the LLM decide whether to view via load_image or just operate on the file. Tool result images (role=tool, e.g. load_image) are base64-encoded into a synthetic user message appended after the tool message, since many LLM APIs don't support image_url in tool messages. Co-Authored-By: Claude Opus 4.6 * fix(media): preserve tool-message ordering for multi-tool-call scenarios Move synthetic user message (carrying base64 tool images) to after the entire contiguous tool-message block instead of immediately after each tool message. This preserves the assistant→tool→tool ordering required by OpenAI-compatible APIs. Also fix load_image to use generic [image: photo] placeholder so injectPathTags can properly replace it with the actual path. Co-Authored-By: Claude Opus 4.6 * fix(test): update load_image test for [image: photo] placeholder The test was checking ForLLM for the media:// ref, but load_image now emits the generic [image: photo] placeholder instead. Co-Authored-By: Claude Opus 4.6 * fix(media): match all channel image placeholders in injectPathTags Different channels emit different placeholder formats — Telegram/Feishu use [image: photo], WeCom/WeChat/Line use bare [image], QQ/Discord use [image: ]. The previous string-match code only handled [image: photo], so for the other channels the path tag was appended as a duplicate, producing content like "[image] [image:/path]". Switch to per-type regex that matches all generic placeholder shapes while leaving path tags ([image:/path]) untouched. Also fixes the same issue for [audio], [video], [file] tags. Added test coverage for the various placeholder shapes. Co-Authored-By: Claude Opus 4.6 * fix(media): skip path tag append for JSON content (Feishu cards/posts) When content is structured JSON (interactive cards, post messages), injectPathTags now skips the fallback append — only placeholder replacement is attempted. This prevents corrupting JSON payloads like {"schema":"2.0",...} with appended [image:/path] tags. Adds looksLikeJSON() helper and three test cases covering JSON objects, arrays, and an end-to-end resolveMediaRefs scenario with Feishu card content. Co-Authored-By: Claude Opus 4.7 (1M context) * fix(media): prepend path tags for JSON content, narrow looksLikeJSON Two fixes from code review: 1. looksLikeJSON now only checks for '{' prefix (not '['), avoiding false positives on regular text like "[update] see attached". 2. For JSON content (Feishu cards/posts), path tags are prepended before the JSON instead of being silently dropped. This ensures the LLM can discover attached images via the path tag while the JSON payload stays valid for downstream parsing. Co-Authored-By: Claude Opus 4.7 (1M context) --------- Co-authored-by: Claude Opus 4.6 --- pkg/agent/agent_media.go | 197 +++++++++++++------- pkg/agent/agent_test.go | 248 +++++++++++++++++++++++--- pkg/agent/steering_test.go | 6 +- pkg/channels/feishu/common.go | 56 ++++++ pkg/channels/feishu/common_test.go | 94 ++++++++++ pkg/channels/feishu/feishu_64.go | 124 ++++++++++--- pkg/channels/feishu/feishu_64_test.go | 7 + pkg/tools/fs/load_image.go | 8 +- pkg/tools/fs/load_image_test.go | 7 +- 9 files changed, 625 insertions(+), 122 deletions(-) diff --git a/pkg/agent/agent_media.go b/pkg/agent/agent_media.go index a773d2ebb..c02c7392c 100644 --- a/pkg/agent/agent_media.go +++ b/pkg/agent/agent_media.go @@ -11,6 +11,7 @@ import ( "encoding/base64" "io" "os" + "regexp" "strings" "github.com/h2non/filetype" @@ -20,24 +21,59 @@ import ( "github.com/sipeed/picoclaw/pkg/providers" ) +// genericPlaceholderRegex matches generic media placeholders emitted by various +// channels: [image], [image: photo], [image: filename.jpg] — but NOT path tags +// like [image:/path/to/file] (path tags have no space after the colon). +var ( + imagePlaceholderRegex = regexp.MustCompile(`\[image(:\s+[^\]]*)?\]`) + audioPlaceholderRegex = regexp.MustCompile(`\[audio(:\s+[^\]]*)?\]`) + videoPlaceholderRegex = regexp.MustCompile(`\[video(:\s+[^\]]*)?\]`) + filePlaceholderRegex = regexp.MustCompile(`\[file(:\s+[^\]]*)?\]`) +) + // resolveMediaRefs resolves media:// refs in messages. -// Images are base64-encoded into the Media array for multimodal LLMs. -// Non-image files (documents, audio, video) have their local path injected -// into Content so the agent can access them via file tools like read_file. +// For user messages: images get path tags only ([image:/path]) so the LLM +// can decide whether to view them via load_image or operate on the file. +// For tool messages: images are base64-encoded and appended as a synthetic +// user message only after the contiguous tool-message block ends, so we don't +// break the tool-results-must-immediately-follow-assistant constraint that +// LLM APIs enforce. +// Non-image files always get path tags regardless of role. // Returns a new slice; original messages are not mutated. func resolveMediaRefs(messages []providers.Message, store media.MediaStore, maxSize int) []providers.Message { if store == nil { return messages } - result := make([]providers.Message, len(messages)) - copy(result, messages) + result := make([]providers.Message, 0, len(messages)) + var pendingToolImages []string + + for idx, m := range messages { + // When leaving a tool-message block, flush any accumulated images + // as a synthetic user message. + if m.Role != "tool" && len(pendingToolImages) > 0 { + result = append(result, providers.Message{ + Role: "user", + Content: "[Loaded image from tool result above]", + Media: pendingToolImages, + }) + pendingToolImages = nil + } - for i, m := range result { if len(m.Media) == 0 { + result = append(result, m) + if idx == len(messages)-1 && len(pendingToolImages) > 0 { + result = append(result, providers.Message{ + Role: "user", + Content: "[Loaded image from tool result above]", + Media: pendingToolImages, + }) + pendingToolImages = nil + } continue } + msg := m resolved := make([]string, 0, len(m.Media)) var pathTags []string @@ -66,27 +102,77 @@ func resolveMediaRefs(messages []providers.Message, store media.MediaStore, maxS } mime := detectMIME(localPath, meta) + pathTags = append(pathTags, buildPathTag(mime, localPath)) - if strings.HasPrefix(mime, "image/") { + if m.Role == "tool" && strings.HasPrefix(mime, "image/") { dataURL := encodeImageToDataURL(localPath, mime, info, maxSize) if dataURL != "" { - resolved = append(resolved, dataURL) + pendingToolImages = append(pendingToolImages, dataURL) } - continue } - - pathTags = append(pathTags, buildPathTag(mime, localPath)) } - result[i].Media = resolved + msg.Media = resolved if len(pathTags) > 0 { - result[i].Content = injectPathTags(result[i].Content, pathTags) + msg.Content = injectPathTags(msg.Content, pathTags) + } + result = append(result, msg) + + // If this is the last message and we have pending images, flush them. + if idx == len(messages)-1 && len(pendingToolImages) > 0 { + result = append(result, providers.Message{ + Role: "user", + Content: "[Loaded image from tool result above]", + Media: pendingToolImages, + }) + pendingToolImages = nil } } return result } +// encodeImageToDataURL base64-encodes an image file into a data URL. +// Returns empty string if the file exceeds maxSize or encoding fails. +func encodeImageToDataURL(localPath, mime string, info os.FileInfo, maxSize int) string { + if info.Size() > int64(maxSize) { + logger.WarnCF("agent", "Media file too large, skipping", map[string]any{ + "path": localPath, + "size": info.Size(), + "max_size": maxSize, + }) + return "" + } + + f, err := os.Open(localPath) + if err != nil { + logger.WarnCF("agent", "Failed to open media file", map[string]any{ + "path": localPath, + "error": err.Error(), + }) + return "" + } + defer f.Close() + + prefix := "data:" + mime + ";base64," + encodedLen := base64.StdEncoding.EncodedLen(int(info.Size())) + var buf bytes.Buffer + buf.Grow(len(prefix) + encodedLen) + buf.WriteString(prefix) + + encoder := base64.NewEncoder(base64.StdEncoding, &buf) + if _, err := io.Copy(encoder, f); err != nil { + logger.WarnCF("agent", "Failed to encode media file", map[string]any{ + "path": localPath, + "error": err.Error(), + }) + return "" + } + encoder.Close() + + return buf.String() +} + func buildArtifactTags(store media.MediaStore, refs []string) []string { if store == nil || len(refs) == 0 { return nil @@ -137,51 +223,12 @@ func detectMIME(localPath string, meta media.MediaMeta) string { return kind.MIME.Value } -// encodeImageToDataURL base64-encodes an image file into a data URL. -// Returns empty string if the file exceeds maxSize or encoding fails. -func encodeImageToDataURL(localPath, mime string, info os.FileInfo, maxSize int) string { - if info.Size() > int64(maxSize) { - logger.WarnCF("agent", "Media file too large, skipping", map[string]any{ - "path": localPath, - "size": info.Size(), - "max_size": maxSize, - }) - return "" - } - - f, err := os.Open(localPath) - if err != nil { - logger.WarnCF("agent", "Failed to open media file", map[string]any{ - "path": localPath, - "error": err.Error(), - }) - return "" - } - defer f.Close() - - prefix := "data:" + mime + ";base64," - encodedLen := base64.StdEncoding.EncodedLen(int(info.Size())) - var buf bytes.Buffer - buf.Grow(len(prefix) + encodedLen) - buf.WriteString(prefix) - - encoder := base64.NewEncoder(base64.StdEncoding, &buf) - if _, err := io.Copy(encoder, f); err != nil { - logger.WarnCF("agent", "Failed to encode media file", map[string]any{ - "path": localPath, - "error": err.Error(), - }) - return "" - } - encoder.Close() - - return buf.String() -} - // buildPathTag creates a structured tag exposing the local file path. -// Tag type is derived from MIME: [audio:/path], [video:/path], or [file:/path]. +// Tag type is derived from MIME: [image:/path], [audio:/path], [video:/path], or [file:/path]. func buildPathTag(mime, localPath string) string { switch { + case strings.HasPrefix(mime, "image/"): + return "[image:" + localPath + "]" case strings.HasPrefix(mime, "audio/"): return "[audio:" + localPath + "]" case strings.HasPrefix(mime, "video/"): @@ -192,22 +239,41 @@ func buildPathTag(mime, localPath string) string { } // injectPathTags replaces generic media tags in content with path-bearing versions, -// or appends if no matching generic tag is found. +// or appends if no matching generic tag is found. Channels emit a few different +// placeholder formats — [image], [image: photo], [image: filename.jpg] — so we +// match all of them via regex while leaving path tags ([image:/path]) untouched. +// +// When content is structured data (e.g., JSON from Feishu interactive cards or +// post messages), tags are only injected via placeholder replacement — never +// appended — to avoid corrupting the payload. func injectPathTags(content string, tags []string) string { + isStructured := looksLikeJSON(content) for _, tag := range tags { - var generic string + var pattern *regexp.Regexp switch { + case strings.HasPrefix(tag, "[image:"): + pattern = imagePlaceholderRegex case strings.HasPrefix(tag, "[audio:"): - generic = "[audio]" + pattern = audioPlaceholderRegex case strings.HasPrefix(tag, "[video:"): - generic = "[video]" + pattern = videoPlaceholderRegex case strings.HasPrefix(tag, "[file:"): - generic = "[file]" + pattern = filePlaceholderRegex } - if generic != "" && strings.Contains(content, generic) { - content = strings.Replace(content, generic, tag, 1) - } else if content == "" { + if pattern != nil { + if loc := pattern.FindStringIndex(content); loc != nil { + content = content[:loc[0]] + tag + content[loc[1]:] + continue + } + } + + if isStructured { + content = tag + "\n" + content + continue + } + + if content == "" { content = tag } else { content += " " + tag @@ -215,3 +281,8 @@ func injectPathTags(content string, tags []string) string { } return content } + +func looksLikeJSON(s string) bool { + s = strings.TrimSpace(s) + return len(s) > 1 && s[0] == '{' +} diff --git a/pkg/agent/agent_test.go b/pkg/agent/agent_test.go index 4047ab74d..f326e2acb 100644 --- a/pkg/agent/agent_test.go +++ b/pkg/agent/agent_test.go @@ -1781,17 +1781,22 @@ func (m *artifactThenSendProvider) Chat( if messages[i].Role != "tool" { continue } - start := strings.Index(messages[i].Content, "[file:") - if start < 0 { - continue + for _, prefix := range []string{"[image:", "[file:", "[audio:", "[video:"} { + start := strings.Index(messages[i].Content, prefix) + if start < 0 { + continue + } + rest := messages[i].Content[start+len(prefix):] + end := strings.Index(rest, "]") + if end < 0 { + continue + } + artifactPath = rest[:end] + break } - rest := messages[i].Content[start+len("[file:"):] - end := strings.Index(rest, "]") - if end < 0 { - continue + if artifactPath != "" { + break } - artifactPath = rest[:end] - break } if artifactPath == "" { return nil, fmt.Errorf("provider did not receive artifact path in tool result") @@ -4656,7 +4661,7 @@ func TestRun_PicoToolFeedbackSuppressesDuplicateInterimAssistantContent(t *testi } } -func TestResolveMediaRefs_ResolvesToBase64(t *testing.T) { +func TestResolveMediaRefs_ImageInjectsPathTag(t *testing.T) { store := media.NewFileMediaStore() dir := t.TempDir() @@ -4684,15 +4689,110 @@ func TestResolveMediaRefs_ResolvesToBase64(t *testing.T) { } result := resolveMediaRefs(messages, store, config.DefaultMaxMediaSize) - if len(result[0].Media) != 1 { - t.Fatalf("expected 1 resolved media, got %d", len(result[0].Media)) + if len(result[0].Media) != 0 { + t.Fatalf("expected 0 media (images use path tags), got %d", len(result[0].Media)) } - if !strings.HasPrefix(result[0].Media[0], "data:image/png;base64,") { - t.Fatalf("expected data:image/png;base64, prefix, got %q", result[0].Media[0][:40]) + localPath, _, _ := store.ResolveWithMeta(ref) + expectedContent := "describe this [image:" + localPath + "]" + if result[0].Content != expectedContent { + t.Fatalf("expected content %q, got %q", expectedContent, result[0].Content) } } -func TestResolveMediaRefs_SkipsOversizedFile(t *testing.T) { +func TestResolveMediaRefs_ToolRoleImageAppendedAsUserMessage(t *testing.T) { + store := media.NewFileMediaStore() + dir := t.TempDir() + + pngPath := filepath.Join(dir, "tool-result.png") + pngHeader := []byte{ + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature + 0x00, 0x00, 0x00, 0x0D, // IHDR length + 0x49, 0x48, 0x44, 0x52, // "IHDR" + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, // 1x1 RGB + 0x00, 0x00, 0x00, // no interlace + 0x90, 0x77, 0x53, 0xDE, // CRC + } + if err := os.WriteFile(pngPath, pngHeader, 0o644); err != nil { + t.Fatal(err) + } + ref, _ := store.Store(pngPath, media.MediaMeta{}, "test") + + messages := []providers.Message{ + {Role: "tool", Content: "Image loaded", Media: []string{ref}}, + } + result := resolveMediaRefs(messages, store, config.DefaultMaxMediaSize) + + // Tool message should have path tag but no base64 + if len(result[0].Media) != 0 { + t.Fatalf("expected 0 media in tool message, got %d", len(result[0].Media)) + } + localPath, _, _ := store.ResolveWithMeta(ref) + if !strings.Contains(result[0].Content, "[image:"+localPath+"]") { + t.Fatalf("expected image path tag in tool content, got %q", result[0].Content) + } + + // A synthetic user message with base64 should follow + if len(result) != 2 { + t.Fatalf("expected 2 messages (tool + synthetic user), got %d", len(result)) + } + if result[1].Role != "user" { + t.Fatalf("expected synthetic message role=user, got %q", result[1].Role) + } + if len(result[1].Media) != 1 { + t.Fatalf("expected 1 base64 media in synthetic user message, got %d", len(result[1].Media)) + } + if !strings.HasPrefix(result[1].Media[0], "data:image/png;base64,") { + t.Fatalf("expected data:image/png;base64, prefix, got %q", result[1].Media[0][:40]) + } +} + +func TestResolveMediaRefs_MultiToolCallPreservesOrdering(t *testing.T) { + store := media.NewFileMediaStore() + dir := t.TempDir() + + // Create image for tool #1 + pngPath := filepath.Join(dir, "loaded.png") + pngHeader := []byte{ + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature + 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, // IHDR + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, + 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xDE, + } + os.WriteFile(pngPath, pngHeader, 0o644) + imgRef, _ := store.Store(pngPath, media.MediaMeta{}, "test") + + // Simulate: assistant called load_image + read_file, two tool results follow + messages := []providers.Message{ + {Role: "assistant", Content: "Let me load the image and read the file."}, + {Role: "tool", Content: "Image loaded [image: photo]", Media: []string{imgRef}}, + {Role: "tool", Content: "file contents here"}, + } + result := resolveMediaRefs(messages, store, config.DefaultMaxMediaSize) + + // assistant, tool#1, tool#2 must remain contiguous — no user in between + if result[0].Role != "assistant" { + t.Fatalf("result[0] expected assistant, got %q", result[0].Role) + } + if result[1].Role != "tool" { + t.Fatalf("result[1] expected tool, got %q", result[1].Role) + } + if result[2].Role != "tool" { + t.Fatalf("result[2] expected tool, got %q", result[2].Role) + } + + // Synthetic user message should come AFTER the tool block + if len(result) != 4 { + t.Fatalf("expected 4 messages (assistant + 2 tool + synthetic user), got %d", len(result)) + } + if result[3].Role != "user" { + t.Fatalf("result[3] expected user, got %q", result[3].Role) + } + if len(result[3].Media) != 1 || !strings.HasPrefix(result[3].Media[0], "data:image/png;base64,") { + t.Fatal("expected synthetic user message to contain base64 image") + } +} + +func TestResolveMediaRefs_OversizedImageSkipsBase64KeepsPathTag(t *testing.T) { store := media.NewFileMediaStore() dir := t.TempDir() @@ -4714,6 +4814,11 @@ func TestResolveMediaRefs_SkipsOversizedFile(t *testing.T) { if len(result[0].Media) != 0 { t.Fatalf("expected 0 media (oversized), got %d", len(result[0].Media)) } + localPath, _, _ := store.ResolveWithMeta(ref) + expected := "hi [image:" + localPath + "]" + if result[0].Content != expected { + t.Fatalf("expected content %q, got %q", expected, result[0].Content) + } } func TestResolveMediaRefs_UnknownTypeInjectsPath(t *testing.T) { @@ -4791,11 +4896,13 @@ func TestResolveMediaRefs_UsesMetaContentType(t *testing.T) { } result := resolveMediaRefs(messages, store, config.DefaultMaxMediaSize) - if len(result[0].Media) != 1 { - t.Fatalf("expected 1 media, got %d", len(result[0].Media)) + if len(result[0].Media) != 0 { + t.Fatalf("expected 0 media (images use path tags), got %d", len(result[0].Media)) } - if !strings.HasPrefix(result[0].Media[0], "data:image/jpeg;base64,") { - t.Fatalf("expected jpeg prefix, got %q", result[0].Media[0][:30]) + localPath, _, _ := store.ResolveWithMeta(ref) + expectedContent := "hi [image:" + localPath + "]" + if result[0].Content != expectedContent { + t.Fatalf("expected content %q, got %q", expectedContent, result[0].Content) } } @@ -4885,6 +4992,98 @@ func TestResolveMediaRefs_NoGenericTagAppendsPath(t *testing.T) { } } +func TestInjectPathTags_HandlesVariousChannelPlaceholders(t *testing.T) { + cases := []struct { + name string + content string + tag string + want string + }{ + // Telegram / Feishu format + {"image_photo", "[image: photo]", "[image:/tmp/p.png]", "[image:/tmp/p.png]"}, + // WeCom / WeChat / Line format + {"bare_image", "[image]", "[image:/tmp/p.png]", "[image:/tmp/p.png]"}, + // QQ / Discord format with filename + {"image_filename", "[image: pic.jpg]", "[image:/tmp/p.png]", "[image:/tmp/p.png]"}, + {"audio_with_filename", "[audio: voice.m4a]", "[audio:/tmp/a.m4a]", "[audio:/tmp/a.m4a]"}, + {"bare_audio", "[audio]", "[audio:/tmp/a.m4a]", "[audio:/tmp/a.m4a]"}, + {"bare_video", "[video]", "[video:/tmp/v.mp4]", "[video:/tmp/v.mp4]"}, + {"bare_file", "[file]", "[file:/tmp/f.pdf]", "[file:/tmp/f.pdf]"}, + // Mixed surrounding text + { + "with_text", + "hello [image] world", + "[image:/tmp/p.png]", + "hello [image:/tmp/p.png] world", + }, + // No placeholder — append + {"no_placeholder", "hello world", "[image:/tmp/p.png]", "hello world [image:/tmp/p.png]"}, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + got := injectPathTags(tc.content, []string{tc.tag}) + if got != tc.want { + t.Errorf("expected %q, got %q", tc.want, got) + } + }) + } +} + +func TestInjectPathTags_DoesNotReplacePathTag(t *testing.T) { + // If content already contains a path tag, we must not touch it. + content := "see [image:/already/placed.png] thanks" + got := injectPathTags(content, []string{"[image:/new/path.png]"}) + want := "see [image:/already/placed.png] thanks [image:/new/path.png]" + if got != want { + t.Fatalf("expected %q, got %q", want, got) + } +} + +func TestInjectPathTags_PrependsForJSONContent(t *testing.T) { + jsonContent := `{"schema":"2.0","body":{"elements":[{"tag":"img","img_key":"img_123"}]}}` + got := injectPathTags(jsonContent, []string{"[image:/tmp/photo.png]"}) + want := "[image:/tmp/photo.png]\n" + jsonContent + if got != want { + t.Fatalf("expected tag prepended to JSON, got %q", got) + } +} + +func TestInjectPathTags_BracketTextNotTreatedAsJSON(t *testing.T) { + content := "[update] see attached report" + got := injectPathTags(content, []string{"[file:/tmp/report.pdf]"}) + want := "[update] see attached report [file:/tmp/report.pdf]" + if got != want { + t.Fatalf("expected tag appended to bracket text, got %q", got) + } +} + +func TestResolveMediaRefs_JSONContentPrependsPathTag(t *testing.T) { + store := media.NewFileMediaStore() + dir := t.TempDir() + + pngPath := filepath.Join(dir, "card_img.png") + pngHeader := []byte{ + 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, + 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, + 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xDE, + } + os.WriteFile(pngPath, pngHeader, 0o644) + ref, _ := store.Store(pngPath, media.MediaMeta{ContentType: "image/png"}, "test") + + jsonContent := `{"schema":"2.0","body":{"elements":[{"tag":"img","img_key":"img_123"}]}}` + messages := []providers.Message{ + {Role: "user", Content: jsonContent, Media: []string{ref}}, + } + result := resolveMediaRefs(messages, store, config.DefaultMaxMediaSize) + + want := "[image:" + pngPath + "]\n" + jsonContent + if result[0].Content != want { + t.Fatalf("expected path tag prepended to JSON content, got %q", result[0].Content) + } +} + func TestResolveMediaRefs_EmptyContentGetsPathTag(t *testing.T) { store := media.NewFileMediaStore() dir := t.TempDir() @@ -4928,13 +5127,12 @@ func TestResolveMediaRefs_MixedImageAndFile(t *testing.T) { } result := resolveMediaRefs(messages, store, config.DefaultMaxMediaSize) - if len(result[0].Media) != 1 { - t.Fatalf("expected 1 media (image only), got %d", len(result[0].Media)) + if len(result[0].Media) != 0 { + t.Fatalf("expected 0 media (all types use path tags), got %d", len(result[0].Media)) } - if !strings.HasPrefix(result[0].Media[0], "data:image/png;base64,") { - t.Fatal("expected image to be base64 encoded") - } - expectedContent := "check these [file:" + pdfPath + "]" + imgLocalPath, _, _ := store.ResolveWithMeta(imgRef) + pdfLocalPath, _, _ := store.ResolveWithMeta(fileRef) + expectedContent := "check these [file:" + pdfLocalPath + "] [image:" + imgLocalPath + "]" if result[0].Content != expectedContent { t.Fatalf("expected content %q, got %q", expectedContent, result[0].Content) } diff --git a/pkg/agent/steering_test.go b/pkg/agent/steering_test.go index bba988672..1ff699976 100644 --- a/pkg/agent/steering_test.go +++ b/pkg/agent/steering_test.go @@ -1051,16 +1051,16 @@ func TestAgentLoop_Continue_PreservesSteeringMedia(t *testing.T) { foundResolvedMedia := false for _, msg := range msgs { - if msg.Role != "user" || msg.Content != "describe this image" || len(msg.Media) != 1 { + if msg.Role != "user" || !strings.Contains(msg.Content, "describe this image") { continue } - if strings.HasPrefix(msg.Media[0], "data:image/png;base64,") { + if strings.Contains(msg.Content, "[image:") { foundResolvedMedia = true break } } if !foundResolvedMedia { - t.Fatal("expected continue path to inject steering media into the provider request") + t.Fatal("expected continue path to inject image path tag into the provider request") } defaultAgent := al.registry.GetDefaultAgent() diff --git a/pkg/channels/feishu/common.go b/pkg/channels/feishu/common.go index 81238460a..95579df09 100644 --- a/pkg/channels/feishu/common.go +++ b/pkg/channels/feishu/common.go @@ -64,6 +64,62 @@ func extractJSONStringField(content, field string) string { // Format: {"image_key": "img_xxx"} func extractImageKey(content string) string { return extractJSONStringField(content, "image_key") } +// extractPostImageKeys extracts all image_key values from a Feishu post (rich text) +// message. Post messages have nested arrays of elements where images appear as +// {"tag":"img","image_key":"img_xxx"}. +func extractPostImageKeys(rawContent string) []string { + if rawContent == "" { + return nil + } + + var post map[string]json.RawMessage + if err := json.Unmarshal([]byte(rawContent), &post); err != nil { + return nil + } + + var keys []string + seen := make(map[string]struct{}) + + collectFromRows := func(contentRaw json.RawMessage) { + var rows [][]map[string]any + if err := json.Unmarshal(contentRaw, &rows); err != nil { + return + } + for _, row := range rows { + for _, elem := range row { + if tag, _ := elem["tag"].(string); tag == "img" { + if ik, _ := elem["image_key"].(string); ik != "" { + if _, dup := seen[ik]; !dup { + seen[ik] = struct{}{} + keys = append(keys, ik) + } + } + } + } + } + } + + // Flat format: {"title":"...", "content":[[...]]} + if contentRaw, ok := post["content"]; ok { + collectFromRows(contentRaw) + } + + // Localized format: {"zh_cn": {"title":"...", "content":[[...]]}, ...} + for _, raw := range post { + var locale map[string]json.RawMessage + if err := json.Unmarshal(raw, &locale); err != nil { + continue + } + contentRaw, ok := locale["content"] + if !ok { + continue + } + collectFromRows(contentRaw) + } + + return keys +} + // extractFileKey extracts the file_key from a Feishu file/audio message content JSON. // Format: {"file_key": "file_xxx", "file_name": "...", ...} func extractFileKey(content string) string { return extractJSONStringField(content, "file_key") } diff --git a/pkg/channels/feishu/common_test.go b/pkg/channels/feishu/common_test.go index ff4af0148..dcf7861a2 100644 --- a/pkg/channels/feishu/common_test.go +++ b/pkg/channels/feishu/common_test.go @@ -291,6 +291,100 @@ func TestStripMentionPlaceholders(t *testing.T) { } } +func TestExtractPostImageKeys(t *testing.T) { + tests := []struct { + name string + content string + want []string + }{ + { + name: "empty content", + content: "", + want: nil, + }, + { + name: "invalid JSON", + content: "not json", + want: nil, + }, + { + name: "post with no images", + content: `{"zh_cn":{"title":"Title","content":[[{"tag":"text","text":"hello"}]]}}`, + want: nil, + }, + { + name: "post with one image", + content: `{"zh_cn":{"title":"","content":[[{"tag":"img","image_key":"img_v3_001"}]]}}`, + want: []string{"img_v3_001"}, + }, + { + name: "post with multiple images", + content: `{"zh_cn":{"title":"","content":[[{"tag":"text","text":"see"},{"tag":"img","image_key":"img_001"}],[{"tag":"img","image_key":"img_002"}]]}}`, + want: []string{"img_001", "img_002"}, + }, + { + name: "post with text and image mixed in row", + content: `{"zh_cn":{"title":"","content":[[{"tag":"text","text":"hi"},{"tag":"img","image_key":"img_mix"}]]}}`, + want: []string{"img_mix"}, + }, + { + name: "en_us locale", + content: `{"en_us":{"title":"","content":[[{"tag":"img","image_key":"img_en"}]]}}`, + want: []string{"img_en"}, + }, + { + name: "multiple locales with distinct images", + content: `{"zh_cn":{"title":"","content":[[{"tag":"img","image_key":"img_zh"}]]},"en_us":{"title":"","content":[[{"tag":"img","image_key":"img_en"}]]}}`, + want: []string{"img_zh", "img_en"}, + }, + { + name: "duplicate image_key across locales is deduplicated", + content: `{"zh_cn":{"title":"","content":[[{"tag":"img","image_key":"img_same"}]]},"en_us":{"title":"","content":[[{"tag":"img","image_key":"img_same"}]]}}`, + want: []string{"img_same"}, + }, + { + name: "image with empty image_key", + content: `{"zh_cn":{"title":"","content":[[{"tag":"img","image_key":""}]]}}`, + want: nil, + }, + { + name: "flat format without locale wrapper", + content: `{"title":"","content":[[{"tag":"img","image_key":"img_v3_flat","width":1826,"height":338}],[{"tag":"text","text":" check this image","style":[]}]]}`, + want: []string{"img_v3_flat"}, + }, + { + name: "flat format multiple images", + content: `{"title":"","content":[[{"tag":"img","image_key":"img_flat_1"}],[{"tag":"img","image_key":"img_flat_2"},{"tag":"text","text":"desc"}]]}`, + want: []string{"img_flat_1", "img_flat_2"}, + }, + { + name: "flat format no images", + content: `{"title":"Test","content":[[{"tag":"text","text":"just text"}]]}`, + want: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := extractPostImageKeys(tt.content) + if len(got) != len(tt.want) { + t.Errorf("extractPostImageKeys() = %v, want %v", got, tt.want) + return + } + // Use set comparison to avoid map iteration order dependency + gotSet := make(map[string]bool, len(got)) + for _, v := range got { + gotSet[v] = true + } + for _, v := range tt.want { + if !gotSet[v] { + t.Errorf("extractPostImageKeys() missing expected key %q; got %v", v, got) + } + } + }) + } +} + func TestExtractCardImageKeys(t *testing.T) { tests := []struct { name string diff --git a/pkg/channels/feishu/feishu_64.go b/pkg/channels/feishu/feishu_64.go index 8f3ae39d9..d09c021c7 100644 --- a/pkg/channels/feishu/feishu_64.go +++ b/pkg/channels/feishu/feishu_64.go @@ -803,6 +803,14 @@ func (c *FeishuChannel) downloadInboundMedia( refs = append(refs, ref) } + case larkim.MsgTypePost: + for _, imageKey := range extractPostImageKeys(rawContent) { + ref := c.downloadResource(ctx, messageID, imageKey, "image", ".jpg", store, scope) + if ref != "" { + refs = append(refs, ref) + } + } + case larkim.MsgTypeInteractive: // Extract and download images embedded in interactive cards feishuKeys, _ := extractCardImageKeys(rawContent) @@ -842,12 +850,41 @@ func (c *FeishuChannel) downloadInboundMedia( // downloadResource downloads a message resource (image/file) from Feishu, // writes it to the project media directory, and stores the reference in MediaStore. // fallbackExt (e.g. ".jpg") is appended when the resolved filename has no extension. +// +// For image resources, if the primary MessageResource.Get API fails (which +// requires im:message or im:message:readonly scope), a fallback to the +// Image.Get API (which requires im:resource scope) is attempted. This ensures +// image downloads succeed regardless of which permission the user has granted. func (c *FeishuChannel) downloadResource( ctx context.Context, messageID, fileKey, resourceType, fallbackExt string, store media.MediaStore, scope string, ) string { + file, filename := c.fetchResourceData(ctx, messageID, fileKey, resourceType) + if file == nil { + return "" + } + if closer, ok := file.(io.Closer); ok { + defer closer.Close() + } + + if filename == "" { + filename = fileKey + } + if filepath.Ext(filename) == "" && fallbackExt != "" { + filename += fallbackExt + } + + return c.storeResourceFile(ctx, messageID, fileKey, filename, file, store, scope) +} + +// fetchResourceData tries to download a resource from Feishu, first via +// MessageResource.Get, then falling back to Image.Get for image resources. +func (c *FeishuChannel) fetchResourceData( + ctx context.Context, + messageID, fileKey, resourceType string, +) (io.Reader, string) { req := larkim.NewGetMessageResourceReqBuilder(). MessageId(messageID). FileKey(fileKey). @@ -855,41 +892,80 @@ func (c *FeishuChannel) downloadResource( Build() resp, err := c.client.Im.V1.MessageResource.Get(ctx, req) + if err == nil && resp.Success() && resp.File != nil { + return resp.File, resp.FileName + } + if err != nil { - logger.ErrorCF("feishu", "Failed to download resource", map[string]any{ + logger.WarnCF("feishu", "MessageResource.Get failed", map[string]any{ "message_id": messageID, "file_key": fileKey, "error": err.Error(), }) - return "" + } else if !resp.Success() { + c.invalidateTokenOnAuthError(resp.Code) + logger.WarnCF("feishu", "MessageResource.Get api error", map[string]any{ + "message_id": messageID, + "file_key": fileKey, + "code": resp.Code, + "msg": resp.Msg, + }) + } else { + logger.WarnCF("feishu", "MessageResource.Get returned empty file body", map[string]any{ + "message_id": messageID, + "file_key": fileKey, + }) + } + + if resourceType != "image" { + return nil, "" + } + + return c.fetchImageDirect(ctx, fileKey) +} + +// fetchImageDirect downloads an image using the Image.Get API +// (/open-apis/im/v1/images/:image_key), which requires the im:resource scope. +func (c *FeishuChannel) fetchImageDirect(ctx context.Context, imageKey string) (io.Reader, string) { + req := larkim.NewGetImageReqBuilder(). + ImageKey(imageKey). + Build() + + resp, err := c.client.Im.V1.Image.Get(ctx, req) + if err != nil { + logger.ErrorCF("feishu", "Image.Get fallback failed", map[string]any{ + "image_key": imageKey, + "error": err.Error(), + }) + return nil, "" } if !resp.Success() { c.invalidateTokenOnAuthError(resp.Code) - logger.ErrorCF("feishu", "Resource download api error", map[string]any{ - "code": resp.Code, - "msg": resp.Msg, + logger.ErrorCF("feishu", "Image.Get fallback api error", map[string]any{ + "image_key": imageKey, + "code": resp.Code, + "msg": resp.Msg, }) - return "" + return nil, "" } - if resp.File == nil { - return "" - } - // Safely close the underlying reader if it implements io.Closer (e.g. HTTP response body). - if closer, ok := resp.File.(io.Closer); ok { - defer closer.Close() + return nil, "" } - filename := resp.FileName - if filename == "" { - filename = fileKey - } - // If filename still has no extension, append the fallback (like Telegram's ext parameter). - if filepath.Ext(filename) == "" && fallbackExt != "" { - filename += fallbackExt - } + logger.DebugCF("feishu", "Image downloaded via Image.Get fallback", map[string]any{ + "image_key": imageKey, + }) + return resp.File, resp.FileName +} - // Write to the shared picoclaw_media directory using a unique name to avoid collisions. +// storeResourceFile writes downloaded resource data to disk and registers it in the MediaStore. +func (c *FeishuChannel) storeResourceFile( + ctx context.Context, + messageID, fileKey, filename string, + file io.Reader, + store media.MediaStore, + scope string, +) string { mediaDir := media.TempDir() if mkdirErr := os.MkdirAll(mediaDir, 0o700); mkdirErr != nil { logger.ErrorCF("feishu", "Failed to create media directory", map[string]any{ @@ -908,7 +984,7 @@ func (c *FeishuChannel) downloadResource( return "" } - if _, copyErr := io.Copy(out, resp.File); copyErr != nil { + if _, copyErr := io.Copy(out, file); copyErr != nil { out.Close() os.Remove(localPath) logger.ErrorCF("feishu", "Failed to write resource to file", map[string]any{ @@ -943,8 +1019,8 @@ func appendMediaTags(content, messageType string, mediaRefs []string) string { return content } - // Don't append tags to JSON content (interactive cards) - would produce invalid JSON - if messageType == larkim.MsgTypeInteractive { + // Don't append tags to JSON content - would produce invalid JSON + if messageType == larkim.MsgTypeInteractive || messageType == larkim.MsgTypePost { return content } diff --git a/pkg/channels/feishu/feishu_64_test.go b/pkg/channels/feishu/feishu_64_test.go index 48fdf0f74..d256325ad 100644 --- a/pkg/channels/feishu/feishu_64_test.go +++ b/pkg/channels/feishu/feishu_64_test.go @@ -180,6 +180,13 @@ func TestAppendMediaTags(t *testing.T) { mediaRefs: []string{"ref1"}, want: `{"schema":"2.0","body":{"elements":[{"tag":"img","img_key":"img_123"}]}}`, }, + { + name: "post message with images returns content unchanged", + content: `{"zh_cn":{"title":"","content":[[{"tag":"img","image_key":"img_001"}]]}}`, + messageType: "post", + mediaRefs: []string{"ref1"}, + want: `{"zh_cn":{"title":"","content":[[{"tag":"img","image_key":"img_001"}]]}}`, + }, } for _, tt := range tests { diff --git a/pkg/tools/fs/load_image.go b/pkg/tools/fs/load_image.go index 6f612faea..0a67fa120 100644 --- a/pkg/tools/fs/load_image.go +++ b/pkg/tools/fs/load_image.go @@ -147,10 +147,10 @@ func (t *LoadImageTool) Execute(ctx context.Context, args map[string]any) *ToolR return ErrorResult(fmt.Sprintf("failed to register image in media store: %v", err)) } - // Build the tool result text. The media:// ref will be picked up by - // resolveMediaRefs in loop_media.go and converted to a base64 data URL - // before the next LLM call, exactly like channel-received images. - msg := fmt.Sprintf("Image loaded: %s\n[image: %s]", filename, ref) + // Build the tool result text. The media:// ref in Media will be picked + // up by resolveMediaRefs in agent_media.go and base64-encoded for tool + // result messages (role="tool"), so the LLM can see the image content. + msg := fmt.Sprintf("Image loaded: %s\n[image: photo]", filename) return &ToolResult{ ForLLM: msg, diff --git a/pkg/tools/fs/load_image_test.go b/pkg/tools/fs/load_image_test.go index 72f163d81..d33db73be 100644 --- a/pkg/tools/fs/load_image_test.go +++ b/pkg/tools/fs/load_image_test.go @@ -135,9 +135,10 @@ func TestLoadImage_SuccessPath(t *testing.T) { t.Errorf("expected ForLLM to contain '[image:' marker, got: %s", result.ForLLM) } - // 4. ForLLM should also contain the media:// ref - if !strings.Contains(result.ForLLM, result.Media[0]) { - t.Errorf("expected ForLLM to contain media ref %q, got: %s", result.Media[0], result.ForLLM) + // 4. ForLLM should contain the generic [image: photo] placeholder + // (resolveMediaRefs will replace it with the actual path later) + if !strings.Contains(result.ForLLM, "[image: photo]") { + t.Errorf("expected ForLLM to contain '[image: photo]' placeholder, got: %s", result.ForLLM) } // 5. Verify the ref is resolvable in the store From 5db008f3841bab4158069aa0b339f41db319583a Mon Sep 17 00:00:00 2001 From: Guoguo <16666742+imguoguo@users.noreply.github.com> Date: Thu, 30 Apr 2026 11:17:55 +0800 Subject: [PATCH 64/87] fix(channels): dismiss tool feedback animation when turn ends via ResponseHandled (#2713) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(channels): dismiss tool feedback animation when turn ends via ResponseHandled When a tool sets ResponseHandled=true (e.g., send_file), the turn ends without producing a final assistant response. This meant no outbound message triggered FinalizeToolFeedbackMessage, leaving the animation goroutine running indefinitely — editing the Feishu card every 3 seconds with "." / ".." suffixes long after the tool had finished. Fix: call DismissToolFeedback at "Tool output satisfied delivery" so the tracker is cleared and the animation goroutine is stopped immediately. Co-Authored-By: Claude Opus 4.7 (1M context) * fix(adapters): add DismissToolFeedback to channelManagerAdapter The adapter must implement the new interface method added in the previous commit, otherwise the package fails to compile. Co-Authored-By: Claude Opus 4.7 (1M context) * fix(channels): pass InboundContext to DismissToolFeedback for topic-aware keys Telegram forum topics use scoped tracker keys like "chatID/topicID", resolved via ToolFeedbackMessageChatID with the InboundContext. The previous nil context caused the lookup to fall back to the raw chatID, missing the topic-scoped entry and leaving the animation goroutine orphaned in forum-topic conversations. Co-Authored-By: Claude Opus 4.7 (1M context) * style: wrap long function signatures for golines Co-Authored-By: Claude Opus 4.7 (1M context) --------- Co-authored-by: Claude Opus 4.7 (1M context) --- pkg/agent/adapters/channelmanager.go | 6 ++++++ pkg/agent/interfaces/interfaces.go | 7 +++++++ pkg/agent/pipeline_execute.go | 3 +++ pkg/channels/manager.go | 15 +++++++++++++++ 4 files changed, 31 insertions(+) diff --git a/pkg/agent/adapters/channelmanager.go b/pkg/agent/adapters/channelmanager.go index 8265ef99d..ad0840e86 100644 --- a/pkg/agent/adapters/channelmanager.go +++ b/pkg/agent/adapters/channelmanager.go @@ -43,3 +43,9 @@ func (a *channelManagerAdapter) SendMedia(ctx context.Context, msg bus.OutboundM func (a *channelManagerAdapter) SendPlaceholder(ctx context.Context, channel, chatID string) bool { return a.inner.SendPlaceholder(ctx, channel, chatID) } + +func (a *channelManagerAdapter) DismissToolFeedback( + ctx context.Context, channel, chatID string, outboundCtx *bus.InboundContext, +) { + a.inner.DismissToolFeedback(ctx, channel, chatID, outboundCtx) +} diff --git a/pkg/agent/interfaces/interfaces.go b/pkg/agent/interfaces/interfaces.go index bdf483e20..2efec05e1 100644 --- a/pkg/agent/interfaces/interfaces.go +++ b/pkg/agent/interfaces/interfaces.go @@ -44,4 +44,11 @@ type ChannelManager interface { // SendPlaceholder sends a placeholder message (e.g., for audio transcription). SendPlaceholder(ctx context.Context, channel, chatID string) bool + + // DismissToolFeedback clears any tracked tool feedback animation for the + // given channel/chat. Call this when a turn ends without a final response + // (e.g., ResponseHandled tools) to avoid orphaned animation goroutines. + // outboundCtx carries topic/thread info needed for channels that use + // scoped tracker keys (e.g., Telegram forum topics); may be nil. + DismissToolFeedback(ctx context.Context, channel, chatID string, outboundCtx *bus.InboundContext) } diff --git a/pkg/agent/pipeline_execute.go b/pkg/agent/pipeline_execute.go index 9935f2c9e..f6a8eaad6 100644 --- a/pkg/agent/pipeline_execute.go +++ b/pkg/agent/pipeline_execute.go @@ -704,6 +704,9 @@ toolLoop: } ts.setPhase(TurnPhaseCompleted) ts.setFinalContent("") + if al.channelManager != nil && ts.channel != "" { + al.channelManager.DismissToolFeedback(ctx, ts.channel, ts.chatID, ts.opts.InboundContext) + } logger.InfoCF("agent", "Tool output satisfied delivery; ending turn without follow-up LLM", map[string]any{ "agent_id": ts.agent.ID, diff --git a/pkg/channels/manager.go b/pkg/channels/manager.go index d56c4fd9b..c6dcfebe3 100644 --- a/pkg/channels/manager.go +++ b/pkg/channels/manager.go @@ -192,6 +192,21 @@ func clearTrackedToolFeedbackMessage( } } +// DismissToolFeedback clears any tracked tool feedback animation for the +// given channel/chat. This is called when a turn ends without a final +// response (e.g., ResponseHandled tools) to stop orphaned animation goroutines. +// outboundCtx carries topic/thread info for channels that use scoped tracker +// keys (e.g., Telegram forum topics); may be nil for non-topic channels. +func (m *Manager) DismissToolFeedback( + ctx context.Context, channelName, chatID string, outboundCtx *bus.InboundContext, +) { + ch, ok := m.GetChannel(channelName) + if !ok { + return + } + dismissTrackedToolFeedbackMessage(ctx, ch, chatID, outboundCtx) +} + func prepareToolFeedbackMessageContent(ch Channel, content string) string { prepared := strings.TrimSpace(content) if prepared == "" { From dbf5d9ce1ff48e630e053d3dfef78a526b0b5825 Mon Sep 17 00:00:00 2001 From: LC Date: Thu, 30 Apr 2026 16:07:38 +0800 Subject: [PATCH 65/87] fix(seahorse): persist reasoning_content in sqlite history (#2707) * fix(seahorse): persist reasoning_content in sqlite history * fix(openai_compat): clarify DeepSeek reasoning replay rules * style(seahorse): format files of seahorse * fix(openai_compat): cover DeepSeek replay requirements * fix(seahorse): repair missing reasoning_content during bootstrap * fix(seahorse): repair reasoning_content on bootstrap prefix --- pkg/providers/openai_compat/provider.go | 4 + pkg/providers/openai_compat/provider_test.go | 106 +++++++ pkg/seahorse/schema.go | 49 +++ pkg/seahorse/schema_test.go | 47 +++ pkg/seahorse/short_engine.go | 105 ++++++- pkg/seahorse/short_engine_test.go | 312 +++++++++++++++++++ pkg/seahorse/store.go | 87 ++++-- pkg/seahorse/store_test.go | 103 ++++++ 8 files changed, 781 insertions(+), 32 deletions(-) diff --git a/pkg/providers/openai_compat/provider.go b/pkg/providers/openai_compat/provider.go index c3733ce3a..be3e77a43 100644 --- a/pkg/providers/openai_compat/provider.go +++ b/pkg/providers/openai_compat/provider.go @@ -270,6 +270,10 @@ func filterDeepSeekReasoningTurn(messages []Message) []Message { } cloned := msg + // DeepSeek thinking-mode replay only requires reasoning_content for + // turns that participate in a tool interaction round. For plain + // assistant turns between two user messages, the docs say the API will + // ignore reasoning_content on replay, so we strip it here. if cloned.Role == "assistant" && strings.TrimSpace(cloned.ReasoningContent) != "" && !hasToolInteraction { cloned.ReasoningContent = "" } diff --git a/pkg/providers/openai_compat/provider_test.go b/pkg/providers/openai_compat/provider_test.go index 594048ea5..4f68fb393 100644 --- a/pkg/providers/openai_compat/provider_test.go +++ b/pkg/providers/openai_compat/provider_test.go @@ -526,6 +526,112 @@ func TestProviderChat_HistoryCanonicalizationMatrix(t *testing.T) { }) } +func TestProviderChat_DeepSeekDocsReplayRequirements(t *testing.T) { + // DeepSeek's thinking-mode and multi-round chat docs distinguish two cases: + // - for a plain assistant turn between two user messages without tool calls, + // reasoning_content does not need to be replayed and the API ignores it if sent; + // - for a turn that participates in a tool-interaction round, assistant + // reasoning_content must be replayed on subsequent requests. + // + // Keep this behavior explicit here so future changes do not "fix" the + // non-tool stripping based on issue reports that are broader than the + // vendor documentation. + var requestBody map[string]any + + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil { + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + resp := map[string]any{ + "choices": []map[string]any{ + { + "message": map[string]any{"content": "ok"}, + "finish_reason": "stop", + }, + }, + } + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(resp) + })) + defer server.Close() + + p := NewProvider("key", server.URL, "") + p.SetProviderName("deepseek") + + messages := []Message{ + {Role: "user", Content: "Who wrote The Hobbit?"}, + {Role: "assistant", Content: "J.R.R. Tolkien.", ReasoningContent: "I know this from general knowledge."}, + {Role: "user", Content: "What's the weather tomorrow?"}, + { + Role: "assistant", + Content: "Let me check the date first.", + ReasoningContent: "I need tomorrow's date before checking the weather.", + ToolCalls: []ToolCall{{ + ID: "call_date", + Type: "function", + Function: &FunctionCall{ + Name: "get_date", + Arguments: "{}", + }, + }}, + }, + {Role: "tool", ToolCallID: "call_date", Content: "2026-04-29"}, + { + Role: "assistant", + Content: "Tomorrow is 2026-04-30.", + ReasoningContent: "Now I can continue with the weather request.", + }, + {Role: "user", Content: "What about Guangzhou?"}, + } + + _, err := p.Chat(t.Context(), messages, nil, "deepseek-v4-flash", nil) + if err != nil { + t.Fatalf("Chat() error = %v", err) + } + + reqMessages, ok := requestBody["messages"].([]any) + if !ok { + t.Fatalf("messages is not []any: %T", requestBody["messages"]) + } + if len(reqMessages) != len(messages) { + t.Fatalf("len(messages) = %d, want %d", len(reqMessages), len(messages)) + } + + plainAssistant, ok := reqMessages[1].(map[string]any) + if !ok { + t.Fatalf("plain assistant message is not map[string]any: %T", reqMessages[1]) + } + if _, exists := plainAssistant["reasoning_content"]; exists { + t.Fatalf( + "plain DeepSeek turn should omit reasoning_content on replay, got %v", + plainAssistant["reasoning_content"], + ) + } + + toolAssistant, ok := reqMessages[3].(map[string]any) + if !ok { + t.Fatalf("tool assistant message is not map[string]any: %T", reqMessages[3]) + } + if toolAssistant["reasoning_content"] != "I need tomorrow's date before checking the weather." { + t.Fatalf( + "tool assistant reasoning_content = %v, want preserved", + toolAssistant["reasoning_content"], + ) + } + + finalAssistant, ok := reqMessages[5].(map[string]any) + if !ok { + t.Fatalf("final assistant message is not map[string]any: %T", reqMessages[5]) + } + if finalAssistant["reasoning_content"] != "Now I can continue with the weather request." { + t.Fatalf( + "final assistant reasoning_content = %v, want preserved", + finalAssistant["reasoning_content"], + ) + } +} + func TestProviderChat_HTTPError(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Error(w, "bad request", http.StatusBadRequest) diff --git a/pkg/seahorse/schema.go b/pkg/seahorse/schema.go index aa829358b..5b67fe9e0 100644 --- a/pkg/seahorse/schema.go +++ b/pkg/seahorse/schema.go @@ -46,6 +46,7 @@ func runSchema(db *sql.DB) error { conversation_id INTEGER NOT NULL REFERENCES conversations(conversation_id), role TEXT NOT NULL, content TEXT NOT NULL DEFAULT '', + reasoning_content TEXT NOT NULL DEFAULT '', token_count INTEGER NOT NULL DEFAULT 0, created_at TEXT NOT NULL DEFAULT (datetime('now')) )`, @@ -157,9 +158,57 @@ func runSchema(db *sql.DB) error { return err } } + + if err := ensureMessagesReasoningContentColumn(db); err != nil { + return err + } return nil } +func ensureMessagesReasoningContentColumn(db *sql.DB) error { + hasColumn, err := tableHasColumn(db, "messages", "reasoning_content") + if err != nil { + return fmt.Errorf("check messages.reasoning_content: %w", err) + } + if hasColumn { + return nil + } + + if _, err := db.Exec(`ALTER TABLE messages ADD COLUMN reasoning_content TEXT NOT NULL DEFAULT ''`); err != nil { + return fmt.Errorf("add messages.reasoning_content: %w", err) + } + return nil +} + +func tableHasColumn(db *sql.DB, tableName, columnName string) (bool, error) { + rows, err := db.Query(fmt.Sprintf(`PRAGMA table_info(%s)`, tableName)) + if err != nil { + return false, err + } + defer rows.Close() + + for rows.Next() { + var ( + cid int + name string + columnType string + notNull int + defaultVal sql.NullString + pk int + ) + if err := rows.Scan(&cid, &name, &columnType, ¬Null, &defaultVal, &pk); err != nil { + return false, err + } + if name == columnName { + return true, nil + } + } + if err := rows.Err(); err != nil { + return false, err + } + return false, nil +} + // checkFTS5Support verifies that SQLite has FTS5 with trigram tokenizer enabled. // This is required for full-text search with CJK (Chinese, Japanese, Korean) support. func checkFTS5Support(db *sql.DB) error { diff --git a/pkg/seahorse/schema_test.go b/pkg/seahorse/schema_test.go index f3d6a3650..943b742b2 100644 --- a/pkg/seahorse/schema_test.go +++ b/pkg/seahorse/schema_test.go @@ -91,6 +91,53 @@ func TestRunMigrationsIdempotent(t *testing.T) { } } +func TestRunSchemaAddsMessagesReasoningContentColumn(t *testing.T) { + db := openTestDB(t) + + _, err := db.Exec(`CREATE TABLE messages ( + message_id INTEGER PRIMARY KEY AUTOINCREMENT, + conversation_id INTEGER NOT NULL, + role TEXT NOT NULL, + content TEXT NOT NULL DEFAULT '', + token_count INTEGER NOT NULL DEFAULT 0, + created_at TEXT NOT NULL DEFAULT (datetime('now')) + )`) + if err != nil { + t.Fatalf("create legacy messages table: %v", err) + } + + err = runSchema(db) + if err != nil { + t.Fatalf("runSchema: %v", err) + } + + var count int + err = db.QueryRow(`SELECT count(*) FROM pragma_table_info('messages') WHERE name = 'reasoning_content'`). + Scan(&count) + if err != nil { + t.Fatalf("query pragma_table_info: %v", err) + } + if count != 1 { + t.Fatalf("reasoning_content column count = %d, want 1", count) + } + + _, err = db.Exec( + `INSERT INTO conversations (session_key, created_at, updated_at) VALUES (?, datetime('now'), datetime('now'))`, + "reasoning-column-test", + ) + if err != nil { + t.Fatalf("insert conversation: %v", err) + } + + _, err = db.Exec( + `INSERT INTO messages (conversation_id, role, content, reasoning_content, token_count) + VALUES (1, 'assistant', 'answer', 'thinking', 1)`, + ) + if err != nil { + t.Fatalf("insert message with reasoning_content: %v", err) + } +} + func TestMigrationConversationUnique(t *testing.T) { db := openTestDB(t) if err := runSchema(db); err != nil { diff --git a/pkg/seahorse/short_engine.go b/pkg/seahorse/short_engine.go index f584788ce..0a8175617 100644 --- a/pkg/seahorse/short_engine.go +++ b/pkg/seahorse/short_engine.go @@ -253,9 +253,23 @@ func (e *Engine) Ingest(ctx context.Context, sessionKey string, messages []Messa var added *Message var err error if len(msg.Parts) > 0 { - added, err = e.store.AddMessageWithParts(ctx, conv.ConversationID, msg.Role, msg.Parts, msg.TokenCount) + added, err = e.store.AddMessageWithPartsAndReasoning( + ctx, + conv.ConversationID, + msg.Role, + msg.Parts, + msg.ReasoningContent, + msg.TokenCount, + ) } else { - added, err = e.store.AddMessage(ctx, conv.ConversationID, msg.Role, msg.Content, msg.TokenCount) + added, err = e.store.AddMessageWithReasoning( + ctx, + conv.ConversationID, + msg.Role, + msg.Content, + msg.ReasoningContent, + msg.TokenCount, + ) } if err != nil { return nil, fmt.Errorf("add message: %w", err) @@ -420,7 +434,7 @@ func (e *Engine) Bootstrap(ctx context.Context, sessionKey string, messages []Me // Fast path: DB has same count and exact match → no-op if len(dbMsgs) == len(messages) { matched := true - for i := 0; i < len(messages); i++ { + for i := range messages { if !messageMatches(dbMsgs[i], messages[i]) { matched = false break @@ -431,14 +445,21 @@ func (e *Engine) Bootstrap(ctx context.Context, sessionKey string, messages []Me } } - // Find longest matching prefix from the start - anchor := -1 - compareLen := len(dbMsgs) - if compareLen > len(messages) { - compareLen = len(messages) + // Migration repair path: old SeaHorse rows may be missing reasoning_content + // even though the canonical JSONL history already has it. Backfill those + // rows in place so we do not treat this as edited history and leave stale + // summaries/context behind after a partial raw-message rebuild. + if repaired, err := e.repairBootstrapReasoningContent(ctx, dbMsgs, messages); err != nil { + return fmt.Errorf("bootstrap: repair reasoning_content: %w", err) + } else if repaired && len(dbMsgs) == len(messages) { + return nil } - for i := 0; i < compareLen; i++ { + // Find longest matching prefix from the start + anchor := -1 + compareLen := min(len(dbMsgs), len(messages)) + + for i := range compareLen { if messageMatches(dbMsgs[i], messages[i]) { anchor = i } else { @@ -524,6 +545,57 @@ func (e *Engine) Bootstrap(ctx context.Context, sessionKey string, messages []Me return nil } +func (e *Engine) repairBootstrapReasoningContent(ctx context.Context, dbMsgs, messages []Message) (bool, error) { + if len(dbMsgs) == 0 || len(messages) == 0 { + return false, nil + } + + overlap := min(len(messages), len(dbMsgs)) + + var updates []struct { + index int + messageID int64 + reasoningContent string + } + + for i := range overlap { + if !messageMatchesIgnoringReasoning(dbMsgs[i], messages[i]) { + return false, nil + } + if dbMsgs[i].ReasoningContent == messages[i].ReasoningContent { + continue + } + if dbMsgs[i].ReasoningContent != "" || messages[i].ReasoningContent == "" { + return false, nil + } + updates = append(updates, struct { + index int + messageID int64 + reasoningContent string + }{ + index: i, + messageID: dbMsgs[i].ID, + reasoningContent: messages[i].ReasoningContent, + }) + } + + if len(updates) == 0 { + return false, nil + } + + for _, update := range updates { + if err := e.store.UpdateMessageReasoningContent(ctx, update.messageID, update.reasoningContent); err != nil { + return false, err + } + dbMsgs[update.index].ReasoningContent = update.reasoningContent + } + + logger.InfoCF("seahorse", "bootstrap: repaired missing reasoning_content", map[string]any{ + "messages": len(updates), + }) + return true, nil +} + // truncate shortens a string for logging. func truncate(s string, maxLen int) string { if len(s) <= maxLen { @@ -532,12 +604,19 @@ func truncate(s string, maxLen int) string { return s[:maxLen] + "..." } -// messageMatches compares two messages using (role, content) or (role, parts). -// TokenCount is NOT compared because it may be re-estimated differently -// during bootstrap (e.g., via tokenizer.EstimateMessageTokens). +// messageMatches compares two messages using role + reasoning_content and then +// either content or parts. TokenCount is NOT compared because it may be +// re-estimated differently during bootstrap (e.g., via tokenizer.EstimateMessageTokens). // For messages with Parts (tool_use, tool_result), compare Parts instead of Content -// since AddMessageWithParts stores empty Content in DB. +// because structured messages are matched by their parts payload. func messageMatches(a, b Message) bool { + if a.Role != b.Role || a.ReasoningContent != b.ReasoningContent { + return false + } + return messageMatchesIgnoringReasoning(a, b) +} + +func messageMatchesIgnoringReasoning(a, b Message) bool { if a.Role != b.Role { return false } diff --git a/pkg/seahorse/short_engine_test.go b/pkg/seahorse/short_engine_test.go index d64634fb7..2a5c6c5d8 100644 --- a/pkg/seahorse/short_engine_test.go +++ b/pkg/seahorse/short_engine_test.go @@ -320,6 +320,108 @@ func TestEngineIngestWithParts(t *testing.T) { } } +func TestEngineIngestPreservesReasoningContent(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + msgs := []Message{ + { + Role: "assistant", + Content: "world", + ReasoningContent: "let me think this through", + TokenCount: 4, + }, + } + + _, err := eng.Ingest(ctx, "agent:reasoning", msgs) + if err != nil { + t.Fatalf("Ingest: %v", err) + } + + conv, _ := eng.store.GetOrCreateConversation(ctx, "agent:reasoning") + stored, err := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(stored) != 1 { + t.Fatalf("stored messages = %d, want 1", len(stored)) + } + if stored[0].ReasoningContent != "let me think this through" { + t.Errorf( + "stored[0].ReasoningContent = %q, want %q", + stored[0].ReasoningContent, + "let me think this through", + ) + } + + result, err := eng.Assemble(ctx, "agent:reasoning", AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + if len(result.Messages) != 1 { + t.Fatalf("assembled messages = %d, want 1", len(result.Messages)) + } + if result.Messages[0].ReasoningContent != "let me think this through" { + t.Errorf( + "assembled reasoning = %q, want %q", + result.Messages[0].ReasoningContent, + "let me think this through", + ) + } +} + +func TestEngineIngestWithPartsPreservesReasoningContent(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + + msgs := []Message{ + { + Role: "assistant", + ReasoningContent: "I need to inspect the file first", + TokenCount: 10, + Parts: []MessagePart{ + {Type: "tool_use", Name: "read_file", Arguments: `{"path":"/tmp/test"}`, ToolCallID: "tc_123"}, + }, + }, + } + + _, err := eng.Ingest(ctx, "agent:parts-reasoning", msgs) + if err != nil { + t.Fatalf("Ingest: %v", err) + } + + conv, _ := eng.store.GetOrCreateConversation(ctx, "agent:parts-reasoning") + stored, err := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(stored) != 1 { + t.Fatalf("stored messages = %d, want 1", len(stored)) + } + if stored[0].ReasoningContent != "I need to inspect the file first" { + t.Errorf( + "stored reasoning = %q, want %q", + stored[0].ReasoningContent, + "I need to inspect the file first", + ) + } + + result, err := eng.Assemble(ctx, "agent:parts-reasoning", AssembleInput{Budget: 1000}) + if err != nil { + t.Fatalf("Assemble: %v", err) + } + if len(result.Messages) != 1 { + t.Fatalf("assembled messages = %d, want 1", len(result.Messages)) + } + if result.Messages[0].ReasoningContent != "I need to inspect the file first" { + t.Errorf( + "assembled reasoning = %q, want %q", + result.Messages[0].ReasoningContent, + "I need to inspect the file first", + ) + } +} + func TestEngineIngestAssemblePreservesParts(t *testing.T) { eng := newTestEngine(t) ctx := context.Background() @@ -514,6 +616,216 @@ func TestEngineBootstrapIdempotent(t *testing.T) { } } +func TestBootstrapRepairsMissingReasoningContent(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + sessionKey := "agent:repair-reasoning" + + conv, err := eng.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + userMsg, err := eng.store.AddMessage(ctx, conv.ConversationID, "user", "hello", 3) + if err != nil { + t.Fatalf("AddMessage user: %v", err) + } + + assistantMsg, err := eng.store.AddMessage(ctx, conv.ConversationID, "assistant", "world", 3) + if err != nil { + t.Fatalf("AddMessage assistant: %v", err) + } + + err = eng.store.AppendContextMessages( + ctx, + conv.ConversationID, + []int64{userMsg.ID, assistantMsg.ID}, + ) + if err != nil { + t.Fatalf("AppendContextMessages: %v", err) + } + + err = eng.Bootstrap(ctx, sessionKey, []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", ReasoningContent: "let me think this through", TokenCount: 3}, + }) + if err != nil { + t.Fatalf("Bootstrap: %v", err) + } + + stored, err := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(stored) != 2 { + t.Fatalf("stored messages = %d, want 2", len(stored)) + } + if stored[1].ReasoningContent != "let me think this through" { + t.Errorf( + "stored[1].ReasoningContent = %q, want %q", + stored[1].ReasoningContent, + "let me think this through", + ) + } +} + +func TestBootstrapRepairsMissingReasoningContentWithoutDroppingSummaries(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + sessionKey := "agent:repair-reasoning-summary" + + conv, err := eng.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + userMsg, err := eng.store.AddMessage(ctx, conv.ConversationID, "user", "hello", 3) + if err != nil { + t.Fatalf("AddMessage user: %v", err) + } + assistantMsg, err := eng.store.AddMessage(ctx, conv.ConversationID, "assistant", "world", 3) + if err != nil { + t.Fatalf("AddMessage assistant: %v", err) + } + + err = eng.store.AppendContextMessages( + ctx, + conv.ConversationID, + []int64{userMsg.ID, assistantMsg.ID}, + ) + if err != nil { + t.Fatalf("AppendContextMessages: %v", err) + } + + summary, err := eng.store.CreateSummary(ctx, CreateSummaryInput{ + ConversationID: conv.ConversationID, + Kind: SummaryKindLeaf, + Depth: 0, + Content: "summary before repair", + TokenCount: 10, + }) + if err != nil { + t.Fatalf("CreateSummary: %v", err) + } + + err = eng.store.AppendContextSummary(ctx, conv.ConversationID, summary.SummaryID) + if err != nil { + t.Fatalf("AppendContextSummary: %v", err) + } + + err = eng.Bootstrap(ctx, sessionKey, []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", ReasoningContent: "let me think this through", TokenCount: 3}, + }) + if err != nil { + t.Fatalf("Bootstrap: %v", err) + } + + stored, err := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(stored) != 2 { + t.Fatalf("stored messages = %d, want 2", len(stored)) + } + if stored[1].ReasoningContent != "let me think this through" { + t.Errorf( + "stored[1].ReasoningContent = %q, want %q", + stored[1].ReasoningContent, + "let me think this through", + ) + } + + summaries, err := eng.store.GetSummariesByConversation(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetSummariesByConversation: %v", err) + } + if len(summaries) != 1 { + t.Fatalf("summaries = %d, want 1", len(summaries)) + } + if summaries[0].SummaryID != summary.SummaryID { + t.Errorf("SummaryID = %q, want %q", summaries[0].SummaryID, summary.SummaryID) + } + + items, err := eng.store.GetContextItems(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextItems: %v", err) + } + if len(items) != 3 { + t.Fatalf("context items = %d, want 3", len(items)) + } + if items[2].ItemType != "summary" || items[2].SummaryID != summary.SummaryID { + t.Errorf("summary context item = %+v, want summary %q", items[2], summary.SummaryID) + } +} + +func TestBootstrapRepairsMissingReasoningContentOnPrefixBeforeAppendingDelta(t *testing.T) { + eng := newTestEngine(t) + ctx := context.Background() + sessionKey := "agent:repair-reasoning-prefix" + + conv, err := eng.store.GetOrCreateConversation(ctx, sessionKey) + if err != nil { + t.Fatalf("GetOrCreateConversation: %v", err) + } + + userMsg, err := eng.store.AddMessage(ctx, conv.ConversationID, "user", "hello", 3) + if err != nil { + t.Fatalf("AddMessage user: %v", err) + } + assistantMsg, err := eng.store.AddMessage(ctx, conv.ConversationID, "assistant", "world", 3) + if err != nil { + t.Fatalf("AddMessage assistant: %v", err) + } + + err = eng.store.AppendContextMessages( + ctx, + conv.ConversationID, + []int64{userMsg.ID, assistantMsg.ID}, + ) + if err != nil { + t.Fatalf("AppendContextMessages: %v", err) + } + + err = eng.Bootstrap(ctx, sessionKey, []Message{ + {Role: "user", Content: "hello", TokenCount: 3}, + {Role: "assistant", Content: "world", ReasoningContent: "let me think this through", TokenCount: 3}, + {Role: "user", Content: "follow-up", TokenCount: 2}, + }) + if err != nil { + t.Fatalf("Bootstrap: %v", err) + } + + stored, err := eng.store.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(stored) != 3 { + t.Fatalf("stored messages = %d, want 3", len(stored)) + } + if stored[1].ReasoningContent != "let me think this through" { + t.Errorf( + "stored[1].ReasoningContent = %q, want %q", + stored[1].ReasoningContent, + "let me think this through", + ) + } + if stored[2].Content != "follow-up" { + t.Errorf("stored[2].Content = %q, want %q", stored[2].Content, "follow-up") + } + + items, err := eng.store.GetContextItems(ctx, conv.ConversationID) + if err != nil { + t.Fatalf("GetContextItems: %v", err) + } + if len(items) != 3 { + t.Fatalf("context items = %d, want 3", len(items)) + } + if items[2].ItemType != "message" || items[2].MessageID != stored[2].ID { + t.Errorf("last context item = %+v, want appended message %d", items[2], stored[2].ID) + } +} + func TestEngineBootstrapDelta(t *testing.T) { eng := newTestEngine(t) ctx := context.Background() diff --git a/pkg/seahorse/store.go b/pkg/seahorse/store.go index c84aaaf07..0edbbd128 100644 --- a/pkg/seahorse/store.go +++ b/pkg/seahorse/store.go @@ -162,20 +162,31 @@ func (s *Store) getMessageTimeRange(ctx context.Context, convID int64) (time.Tim // AddMessage appends a message to a conversation. func (s *Store) AddMessage(ctx context.Context, convID int64, role, content string, tokenCount int) (*Message, error) { + return s.AddMessageWithReasoning(ctx, convID, role, content, "", tokenCount) +} + +// AddMessageWithReasoning appends a message with reasoning content to a conversation. +func (s *Store) AddMessageWithReasoning( + ctx context.Context, + convID int64, + role, content, reasoningContent string, + tokenCount int, +) (*Message, error) { result, err := s.db.ExecContext(ctx, - "INSERT INTO messages (conversation_id, role, content, token_count) VALUES (?, ?, ?, ?)", - convID, role, content, tokenCount, + "INSERT INTO messages (conversation_id, role, content, reasoning_content, token_count) VALUES (?, ?, ?, ?, ?)", + convID, role, content, reasoningContent, tokenCount, ) if err != nil { return nil, fmt.Errorf("add message: %w", err) } id, _ := result.LastInsertId() return &Message{ - ID: id, - ConversationID: convID, - Role: role, - Content: content, - TokenCount: tokenCount, + ID: id, + ConversationID: convID, + Role: role, + Content: content, + ReasoningContent: reasoningContent, + TokenCount: tokenCount, }, nil } @@ -212,6 +223,18 @@ func (s *Store) AddMessageWithParts( role string, parts []MessagePart, tokenCount int, +) (*Message, error) { + return s.AddMessageWithPartsAndReasoning(ctx, convID, role, parts, "", tokenCount) +} + +// AddMessageWithPartsAndReasoning adds a message with structured parts and reasoning content. +func (s *Store) AddMessageWithPartsAndReasoning( + ctx context.Context, + convID int64, + role string, + parts []MessagePart, + reasoningContent string, + tokenCount int, ) (*Message, error) { tx, err := s.db.BeginTx(ctx, nil) if err != nil { @@ -223,8 +246,8 @@ func (s *Store) AddMessageWithParts( readableContent := partsToReadableContent(parts) result, err := tx.ExecContext(ctx, - "INSERT INTO messages (conversation_id, role, content, token_count) VALUES (?, ?, ?, ?)", - convID, role, readableContent, tokenCount, + "INSERT INTO messages (conversation_id, role, content, reasoning_content, token_count) VALUES (?, ?, ?, ?, ?)", + convID, role, readableContent, reasoningContent, tokenCount, ) if err != nil { return nil, fmt.Errorf("add message: %w", err) @@ -256,11 +279,12 @@ func (s *Store) AddMessageWithParts( // Return message with parts msg := &Message{ - ID: msgID, - ConversationID: convID, - Role: role, - TokenCount: tokenCount, - Parts: make([]MessagePart, len(parts)), + ID: msgID, + ConversationID: convID, + Role: role, + ReasoningContent: reasoningContent, + TokenCount: tokenCount, + Parts: make([]MessagePart, len(parts)), } for i, p := range parts { p.MessageID = msgID @@ -271,7 +295,7 @@ func (s *Store) AddMessageWithParts( // GetMessages retrieves messages for a conversation. func (s *Store) GetMessages(ctx context.Context, convID int64, limit int, beforeID int64) ([]Message, error) { - query := "SELECT message_id, conversation_id, role, content, token_count, created_at FROM messages WHERE conversation_id = ?" + query := "SELECT message_id, conversation_id, role, content, reasoning_content, token_count, created_at FROM messages WHERE conversation_id = ?" args := []any{convID} if beforeID > 0 { query += " AND message_id < ?" @@ -298,6 +322,7 @@ func (s *Store) GetMessages(ctx context.Context, convID int64, limit int, before &msg.ConversationID, &msg.Role, &msg.Content, + &msg.ReasoningContent, &msg.TokenCount, &createdAt, ); err != nil { @@ -335,10 +360,11 @@ func (s *Store) GetMessageCount(ctx context.Context, convID int64) (int, error) func (s *Store) GetMessageByID(ctx context.Context, messageID int64) (*Message, error) { var msg Message var createdAt string - err := s.db.QueryRowContext(ctx, - "SELECT message_id, conversation_id, role, content, token_count, created_at FROM messages WHERE message_id = ?", + err := s.db.QueryRowContext( + ctx, + "SELECT message_id, conversation_id, role, content, reasoning_content, token_count, created_at FROM messages WHERE message_id = ?", messageID, - ).Scan(&msg.ID, &msg.ConversationID, &msg.Role, &msg.Content, &msg.TokenCount, &createdAt) + ).Scan(&msg.ID, &msg.ConversationID, &msg.Role, &msg.Content, &msg.ReasoningContent, &msg.TokenCount, &createdAt) if err == sql.ErrNoRows { return nil, fmt.Errorf("message %d not found", messageID) } @@ -350,6 +376,28 @@ func (s *Store) GetMessageByID(ctx context.Context, messageID int64) (*Message, return &msg, nil } +// UpdateMessageReasoningContent updates reasoning_content for an existing message. +func (s *Store) UpdateMessageReasoningContent(ctx context.Context, messageID int64, reasoningContent string) error { + result, err := s.db.ExecContext( + ctx, + "UPDATE messages SET reasoning_content = ? WHERE message_id = ?", + reasoningContent, + messageID, + ) + if err != nil { + return fmt.Errorf("update message reasoning_content: %w", err) + } + + rowsAffected, err := result.RowsAffected() + if err != nil { + return fmt.Errorf("update message reasoning_content rows affected: %w", err) + } + if rowsAffected == 0 { + return fmt.Errorf("message %d not found", messageID) + } + return nil +} + func (s *Store) loadMessageParts(ctx context.Context, msgID int64) ([]MessagePart, error) { rows, err := s.db.QueryContext(ctx, `SELECT part_id, message_id, type, text, name, arguments, tool_call_id, media_uri, mime_type @@ -534,7 +582,7 @@ func (s *Store) LinkSummaryToMessages(ctx context.Context, summaryID string, mes // GetSummarySourceMessages retrieves source messages for a summary. func (s *Store) GetSummarySourceMessages(ctx context.Context, summaryID string) ([]Message, error) { rows, err := s.db.QueryContext(ctx, - `SELECT m.message_id, m.conversation_id, m.role, m.content, m.token_count, m.created_at + `SELECT m.message_id, m.conversation_id, m.role, m.content, m.reasoning_content, m.token_count, m.created_at FROM summary_messages sm JOIN messages m ON m.message_id = sm.message_id WHERE sm.summary_id = ? @@ -555,6 +603,7 @@ func (s *Store) GetSummarySourceMessages(ctx context.Context, summaryID string) &msg.ConversationID, &msg.Role, &msg.Content, + &msg.ReasoningContent, &msg.TokenCount, &createdAt, ); err != nil { diff --git a/pkg/seahorse/store_test.go b/pkg/seahorse/store_test.go index 89635cc9a..67bed1c11 100644 --- a/pkg/seahorse/store_test.go +++ b/pkg/seahorse/store_test.go @@ -199,6 +199,47 @@ func TestStoreAddAndGetMessages(t *testing.T) { } } +func TestStoreAddAndGetMessagesWithReasoningContent(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:reasoning") + + msg, err := s.AddMessageWithReasoning( + ctx, + conv.ConversationID, + "assistant", + "hello world", + "let me think", + 5, + ) + if err != nil { + t.Fatalf("AddMessageWithReasoning: %v", err) + } + if msg.ReasoningContent != "let me think" { + t.Fatalf("ReasoningContent = %q, want %q", msg.ReasoningContent, "let me think") + } + + msgs, err := s.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(msgs) != 1 { + t.Fatalf("got %d messages, want 1", len(msgs)) + } + if msgs[0].ReasoningContent != "let me think" { + t.Errorf("ReasoningContent = %q, want %q", msgs[0].ReasoningContent, "let me think") + } + + found, err := s.GetMessageByID(ctx, msg.ID) + if err != nil { + t.Fatalf("GetMessageByID: %v", err) + } + if found.ReasoningContent != "let me think" { + t.Errorf("GetMessageByID ReasoningContent = %q, want %q", found.ReasoningContent, "let me think") + } +} + func TestStoreAddMessageWithParts(t *testing.T) { s := openTestStore(t) ctx := context.Background() @@ -233,6 +274,43 @@ func TestStoreAddMessageWithParts(t *testing.T) { } } +func TestStoreAddMessageWithPartsAndReasoningContent(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:parts-reasoning") + + parts := []MessagePart{ + {Type: "tool_use", Name: "read_file", Arguments: `{"path":"/tmp/test"}`, ToolCallID: "tc_123"}, + } + _, err := s.AddMessageWithPartsAndReasoning( + ctx, + conv.ConversationID, + "assistant", + parts, + "need to inspect the file first", + 10, + ) + if err != nil { + t.Fatalf("AddMessageWithPartsAndReasoning: %v", err) + } + + msgs, err := s.GetMessages(ctx, conv.ConversationID, 10, 0) + if err != nil { + t.Fatalf("GetMessages: %v", err) + } + if len(msgs) != 1 { + t.Fatalf("expected 1 message, got %d", len(msgs)) + } + if msgs[0].ReasoningContent != "need to inspect the file first" { + t.Errorf( + "ReasoningContent = %q, want %q", + msgs[0].ReasoningContent, + "need to inspect the file first", + ) + } +} + func TestStoreGetMessageCount(t *testing.T) { s := openTestStore(t) ctx := context.Background() @@ -275,6 +353,31 @@ func TestStoreGetMessageByID(t *testing.T) { } } +func TestStoreUpdateMessageReasoningContent(t *testing.T) { + s := openTestStore(t) + ctx := context.Background() + + conv, _ := s.GetOrCreateConversation(ctx, "agent:update-reasoning") + + msg, err := s.AddMessage(ctx, conv.ConversationID, "assistant", "answer", 3) + if err != nil { + t.Fatalf("AddMessage: %v", err) + } + + err = s.UpdateMessageReasoningContent(ctx, msg.ID, "thinking") + if err != nil { + t.Fatalf("UpdateMessageReasoningContent: %v", err) + } + + found, err := s.GetMessageByID(ctx, msg.ID) + if err != nil { + t.Fatalf("GetMessageByID: %v", err) + } + if found.ReasoningContent != "thinking" { + t.Errorf("ReasoningContent = %q, want %q", found.ReasoningContent, "thinking") + } +} + // --- Summary Operations --- func TestStoreCreateAndGetSummary(t *testing.T) { 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 66/87] * 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 67/87] 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 68/87] 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 69/87] 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 zcmeGDWm}u?(*+7s+=IIpFD}Ks#jUtI#a)8C7I!IH+>29+Yq0st`(-XYa-MUonOSR1th%Zk7CIR^92^{$g8T;!I5O8$4+cFtTYR8U{|65LU+@tBe*g_*AVMu}Sc54AIBf>k>cX~?HYdajdzYrCMo;PrcW)qm zAS&lP+KBh4{~-73es`lrx_1rsw0sk%o3OccQTUPN`3DvC{=`x71#Lq>uocuI}*15lBL;T*bL*$-qK`SMfUZ6P@nnf8>! zUTR>GrpU;qID|uTf%m~C1H{8}7y3_G?1RBKP~@|}9}#8yAskOiy=NZ4e`%V23SFFF44n8IHEc6A7!EJvmZoA$ zArS22!^H;is$M*eu3y|1=XacX9l`hh7Mqu?^=s}AkY>fMNJ$fHhOf~+HH>CaQeeX_VdTyl)9yJXL6?Mfv zP?(uU0lh)RBCzye%a4*9F~m?RUlT`2=4@9FZjV#LGuu(Vh6V?glipwl1rE z6Z#xUgLkg}3v(S$;@gCckJ}Mto?V|1dIAbdqww3FbDKE2`hXzQE3_x2g&3mO-HH0I zwlO^()|mHO3si` zK`v4XtAy^}IZL$PJ%@>Yi(B=kipRtPto7@^NopS$L~;E@r);T1$Uw`8JFN0d6KE8} z`)BUVw3<^LyRb&}hS*83A>e{{VJx}D^Im8uDU^Fu!K^S?S5a|1n?PDVhnb<&DlD-6 zo!v{%Ywcy+_pk7(KX;oYT^s>FbUJ*k_X6>El3V%C@vRB7lpT1cd^R>zVj&F=ApIkm z)D?LZx#4jw4))=KD0gwOamu37{wqiKBPU=PAQVfdlAk)j zk?g)oa3}VVXYR=5f>~{O{;g}w>m>q@j~~5zx4M2g#TE}tRP-95^fHU|kdbtu5^_)z z&09|wb{t1Lmi1^>d11pNN+U(GyUM~diOPe?uxbtqg;?*Js!Za!eH_$v192<+r~*WZ zzDM8@(=;>P#f8Vkl@|B}1|rP;xf%7Bs{(@DL7P+kqzIPjdL`ZMZb&aYaIS7vkYOdWe4?aRTs}=?VJ{#6ee)QIdRI)M3pL=!~`;<{v456Twj{ zaRZUl6_~z%9&QPw0X~`$+~~R}NovMMU*q6hN(*yj5oS9rmDR^LJwi~PVF%$NeY&L)~8;+n(W0e(_s9V0EcCgL3>HLMv}P;z7Y z@kn)Sg`^!o4*W39cD|rst<8bh0_8wer~qsbgXximg4w;t2Z)3RVQ&kPBlC; zgf7!oUOfK@o->-pU&73NSo04-kEbdu(euT2D^YVm3ySFRruGh~f-K*fd+ zOH{IFX2FQyOl$}+YeR=v`6)5)C~J?iB(f&y?DqR6vccWZrSTumXkR#D05p`BV~ZBP zg2EmX^*TONH#Y=!9af}eq#t=p`{u732%VN018gryg-iGO&8(m*9Ns;?>Ic*zTdF(@ zt#-mne$wnAM0+R2&7wi-iqnJx9dn>YOftfoz7`QUPSUi&~}?QnW>!u#6#2jl0S zjSe-rAE{Z=;`rqB3YR$sVQUMcx8~ukGYDD(z26>B3mg9ufkEmYH{w54ZH4MNbU{Bz z4m-^WX~zF7wERw1@uB;-C+au&Un-ZA_P=^Az?vMkc+F1n2Q9oqKRc|?>grGp}^_f~I|*Y!W+?|iEziifh69JXlDV2 z3qdPs^W^*h|D3Xl+;E-4Vj5os55@0cdN~A_k15;Iy{la5ku5z4*ygWyPTo$$jSrgS?y6L+e8G;Gh`|F7tfzO z-FX3*u8ZXrQ(qYt>-ef8160Nj)Z|?;Y~L?QUTcy6eI44yx9@yN2+U&JWKke8T;*@U zR`EI24+n+M_rdqUFVnpjAkNbyS(jkw5uXAHL_JFhjWACgdx;|}8d=?++=Uhpt1&`b z(vyU47O-ed_@*K`+$!E-1suH$R3%5njET&YQ+8$S2r;cadqXDTj<-^~I8BvLO${^_ z_}U;YsGk(XozCNNWq}naG)}X3ibAFof`;*(2*`!3{5?5!CP{Gr`tg*gfJSgDL5q!3 z!?N@7R-*g%KyBr+ie6hbP}RxeC_Z~o!L3DXY8Z$zthZ~)iW0BF&oFb>dw_FaH)?tBXLzJ(9Ck!S#H{D%tdFSQU5Ry+ zY8F-I|1kJLpW<6^gFwJB z2rv3h64irEDU^rNjy%&T%wJ{ zgKtq@4lbG-0v=ah_JePG8H~| zC9>YL)iz9g$>&(cWeA^CaE?DXl*Ro-@X^xIm>*?3e+k-5M}AIUN1Ahbs(S>s<+SF| zHh7=F&8YVKL#mk}nJ}KcrHX#5iY8~~LX(M*2~V%$rPfOBvNdw+=;!2J7Q@{zhq`c= zsKH{h9&VkOzk~j2AXV^C!XB^GeX_=SOTu-g(y*0OPDFY68j=MCzr#0Zso5Gg*(INO zJSl`lGjsyZ8a|JkO3kechzzp9qbkx(Z61+qek-^cVweGdUR*72Ub}Y(J?xOEnj016 z8Mazm?eE7_*{!ywqt+#Od^ToaRYKBi3|f({<4dwr)H4pjS*HJofA5WZfq=BmElIfS zKEk3SF{^{V0^!YAE|u#$Sohg;`wOLu1B2E861#3v&_f#FWk)UPbdB^Ed6Rq@!LDBp z)@UXo@$Kq%$a=>Gg~+p@gJ9Nouey%5?^M?5iP1=JyQ&P%VvgdszS%iApSTKQ8VvTs zDf5QMnw^U#s}i6Z(SBNE?BT7)pgo5py%*Z<_hr>PQSLUt{O#z#WlJ7-Hh3GxWI65u zl3$(IK9L(9=$tjpK3Z>sVx0Y44$IEa`gt{vZt80u7%P@dJf zeHU>-#YA_gb)(hFvj-WV9mwfOEN>+<8+k@Uq>&uL9C2f+gVj!Rr76Z2@G=y%AiS`P)$ghw) zvv&wUe>jE`2ZnMWd-NOR^CAN9|#5YCY)8$p2BK_byHq=weC@%ooZ& z-EVrnDtR1*KJ zNb3+B!+s+Y*H;uR8YxP^_G*GzD@W^VDarxr`2mRUBPk?(f^4ofjERwwv_UtVA)yn*AkJ zLQSFY^BH;5<+hPoq@SveC%lSSsU0$Fdg8|}J2woqdCiSKr)?&zk^$}QyRKVe#h5Vm zRRD36;%)~lXtsyh2wN${OPF@m;vjD3OS1fB>sNu`gOi4UlN&D^FAlTgzD;l<&C`RR zNCD^4DflAz@#nM}73H2?D$BP7rhKrJK#l!%S50EKiRUh~NtC;-ln!+_7MM=Yrz(#+ zFEfc3cERY}fscy3MbPY{@1_AqfiDPf@VTS6JopZk@?Z2)kt0dtQPD`DXML|@EuP$F zxYE|-M5?^FG-8`sKAsb$q|m`6iimy2tMft92kvbuWm*`oT7GN!+?u4zyp8~Lck2LJ z(K%bu4AnNi$BEd&4x%ybGk9l&$zoBciHZ5T)@c9Mnz2*Zr06xh%~JBlaCEK@f$lMh zwoIa2y@Q-5t`|?&#yZTq)!G(KU2bjqyH2ohSJ6d=}+QOiW~gDebL?LprN8z8VGJNyIT@ zb|D-wVz=VADmZ357{o3pY{N9;s zPD@LY5GE=8yK=G`tHFaCkzbeEe-4|gpnkcF=E3c~2f{$n63-Wg>rdeO`=y)KqcA)a zrQMFMhzOsKLS|bY#V{tPkKm*G?dZa;M`!6j{h&3PcR`O?y&fi+w}s;Rd7^=4CsRL7 ze=sw}aB#4h7#6n7RS;h1eEhE6;I6Oi)g2Jj*7LF-uj$1_xz@w4*J{#UR%a;1Z23j0 z(bfP0e<7v8DVWE1zVSJ3Zup?tJFp;5M=^^&EO{tuIVBU1HKW>rou%T<7Bd}bBn#H} z>>k^W4;{S}JD9sTDF7~KAxZO(A)A2W=AIJ11WTOColrNK*ft{R^3{_RRAXCWhjqcD z^qn-fPJT*y1nZ6#Exi%;Vs2ej146fQcwSdV1O=5mX($s5X}ni+em*-9S4zFZ+xv}jz%T{^C`?V#DKlC&)N91sG7#T~qvA&{u=H&0y5zziaj*43_oLYZ#G zmxP2T<$uv4tnMm0CN+5`^ZJ=p52Ks~nOcvTK3zQrKd8MNtiyf=yZ8fj(fcX*XuQB^ z^386>`aD~DxqOfc>ZkqaYsd1glA{H`#-Pg*>cYZ8T?61u?tJy8tDn|t*Rw3!bOHjR z#Uy;_n{X4^KrUDP1&qZ5W(k-07?nxsor4Am)XVjpptEuDVli&2@*gKx7BcZ=rw$+Ppw%^|s_W{_|`>hO06Z7qL939{ddo=)m|gw8)&n|*I+;^ zGALoLCD}cjKKdibXeCGI3!BpKHeR4J#pDr~>-XgJ%gH*dF8IN}w_P|$wlgZ`4O6Jz zR6K)5>IUA~%RV6ZjOh$!=6$K$02T?iaM9b}%_UpR)NVEbjtCaR(?TH40Evg4mEMc? zfd$R54VqZy_q)L<`@f?(*oXw0Yh78%PmdqQRJ#p04Q@{5UaOz6ihNVAsR87mXAn8c z3d(D>5%$|*vEF#)>)v0_U17v5p0Ay<`-E?I)qP!l&S*#ErZ>|x>2a`8xK)K52VpV6 zsh=E&oyEuI2&ik#B$>u6?rndMx=Tu)N6=p6n}Lf}Ghwa|Y}YFgxOP{!8kA-rO$j@$ zq?Ba`fXT9@k102Yl4lfB5Kl8giuyFiV_Uf8?M2e8#%#IrFh|!qm+W{XOtV3FXH{Pi zQZhEG4kZ|fC>ptbZb0j!5OrY$ubuAa{#Tx^<;O=P+6X?CLWy81ku-ySVuBhB5{R;- z8yjswN*`%XVw7nhG~us)i36cgF5}UXFP&Bj01GQxBu%YA%z+4!ro6Vix;8d>tRF=2$>qI}7Sxi>PQ(lZ5U<7FYsrqe#h`|G%z8d8^G7&+h5kxczhR`wjddwyo9 zczdTudsZFTvi1Qbk3oWZ9nl6W)bQN^u4@l}$6Q1scPFhbMhtpT{&|o{*s(hj(oAo0x&NBtX@z^B`h(Y^HiSk z%$}3f+0AAB)}c40YgZt+&43vhf=GJ@mtdnMxF`)^7|9EjAz`h&P1G>ZUbq2=Mw=xI z1G%HIU*!?>|KyQjGjeffa$OiP)M=4jtxPO~esDfB9&PG4D3c!^o%n#$b@fR_Vn*P-Dtd&FBITwD^O&fbkfzQG zXtl#Dzca(6P!ocDFe5_N`!{<}h$&w~kwN+wtCd%ZK)G>Rn^tN()9@NhTq#v0NwxS^1{u>-0e8rH{63C6w&n0mbqnp za$~gkdz5%it5onmWgTg$99F~jp9_O3?yg@p)n4wb-kWMKfI(~IF5UX^QMYGePa8}U zj9yTXZckJ2_cLV=F4FfC_f78_&Q9>RYrNR;K5D_UJSn`Vu^NkL$L@5&lPhkz{YF8D zxWegcIfXEUpzZ)S+*xoR)tTCnhcXtaWfW5+#+^hJM6)X00vX(BuBD0C2iyLn+B43K zWSi2=z^MX~+9Ag}r@FVLexatqKI`%wghmWlHI_x!OC)y<6&b-{vx{11s#8}cQs$vv z!F`#EHiM@?d!9#OW}=DL+#^W~Q$U{jkU@s^dn|E3*RNaf>vTcJ(OflaU`c*`ReO$= zhQ_$Z!-Tk;jtHeG*Z{Ply5EGD+qG~Y*`b+@;Q2`#US zi}>a$Tr4znnXv1w`EuB$mW#4rrsO0;jt+OmG_xlO$xqeyw-so;n2m^}@9t`PFFQI3 zlOMmuI)vMaV)3}5Pl^4k*Kb`oK6OYFSy{1M#xh5CwS`Bs5N37E)F`Hp+>Yt1#Apj; z0RhB!^VHhf+5z4=%Mu*(A@{$%;2%Qqn2Qq2up9kC{`^V(<%Qi+U!>cq$+J7mF5tN;SFd{0l#RyP91n3P89a{}h$ME?1qkmB01ctJyKe z|6!*emf)~`LRn9M$e>}%8k4N!V2NoIvPG((VzU{!`9&0HgbQ!1j?f5l9WcAQsIfuf z&c}Q~e_iB%kl@Mk8ME8gQZss{Lb`2-vEFE%vkb)zA1SZ*Tu%8b-{vVmagz&L#5D6rfB6{ZtCwaJMnNUj!e+%m~-BUx{?G)5{zj_)_}&c=5y zeE0&7TJ2`1{+Ae;SjaVeCVv^wdipA`f-A3 zQQEB0Q=puU8yh+)Jwrsa+o;6ybSTj&iCIP(|NgVMiZNx#VN|q;7+EFY|I|H`NSl8$G#*>iHl=)SuP7gCdLHMV zr?D~hNhGKsuW(Mm?eSEF>aVA;xJ026ODY@ZqLO@Ev?rOp3bC}h;*O%v7}~`^Ydti2 zWm|c*ZQid!%vzdT#`8TDYJvVJxV6Mcqsl55TUL{$EIPBCpvjVhgX@Ooi`nL?sfQ!n z5PY<+2@bD1aZzkVv@pUR%jOqF^9);j-7@=pZUi))l~>;0jwTff z{;6$=}oEewTg@-!Z(?Yt~C?1#bGbhe($I=>2opC;y+szOjT`xmzCl6Ow0#UW*Pjh}$!g3Le^yJDtH`gvZzUFiD=#?Dh+#g}Q zV%JL(8kUt?*HRBfMo)xc5#?eZNCuiWi=a;0)3Qx0=wI)2q7#v&@^KhlZ3hMsF}O4Z zllvm-4IJ_SMjHHMD2v|M)7XX+nMsRoCelUR3aDgB!ak41)R@Xe6*icX=3|g~NZlz)`7PP&+{1vo0uOIVM)drrl-Y6D%9UEc%AHEMC zKf$`yDpm{!$2#~_70fLny|&7*N3!n@&)FxTG!dw@u5V`Hu|D`rf9+JW8<4nq4L@HW zo!1n_*{^y#e9qGm$>%vhqW0Tj-U>pwyWMYQO11ZqTSA18KoPsGtqqaz=-L2{g`@@? z_kk6JHYpqqevHB?luxOmU;Qd77IaENs?rXga_3uJ=KMVzkRekiJ&vf1anxnxkgF2q zvey0flCN}p7LSrNv&xYsgtw^Jw#pn6Bhx_o-#7g+p9t+){oJyi26S z`d&jV7bkV%MuA355_h{%8hHVSgzTCv6&WpMmG`M$)O^|3MmY5so65#ck^F*fsv6^x zYvmDZcIGE|Qpo}m7rcT)zvpwD$7Uk73z>8Hy?i#<1$0yPtPJc-j`sZq<0=g7G0YI+e|qX_#43h?>kI+ZqRvOoE-vfd2JKF%^m)FO z&ex5+YL1JRTUJ|hbCv}*1?u>Y!pms=UQXGGK=h1M9ME2z_R>rMD@w`iY3Njx>@1@o z!rQDzw$eT$OiY?j)Fy+Hhw;VnZmK^}^WSA~fkg(gTQfhki?RB2ifsyrKhIJJ`CsOi z)Kz#%`SD=};zZ)Nv%xynAUN8>i(*l?igzy;g$-Yw~ zw2rMnBAzE75mm}&==UATc@?VnL`w?fzv+E*&yDG8O=jbaO0Fqw{nark#2%qSP!gbW zu(OnqUo{?fa`umUB)}U`*Ep0CyPa23&U^}IHLm51TOA44TuhLNT zQ!$D+&O`3`(h#fh5COki>YdnhHOAg({`TW!38jnR6c*m^MZQozZu>%r`btauXN)oK zsAS%E*{&Cb&fM7uE|1=;x0H!Uh5^V9%M6YEj8QZH9kKF?!T<_h4)K- zjZ(14XJjkQq5H6pJ%GS?Z!2t<&3rQE7ZvSy+KoTU+HUp| z1!XBFS0cX{Apa0LK2-JYJ$e2nPUap{lz`{xBQr;T=?9Ye5HvviY5bQ@jLrO!j>Q{W1W2?oN;FiVrNzXS z=o?dhAW31XwNLoDftSasw@yRqM=q>fXrSD84%lH&PO59TSdJHZk zn?BU#+5?4Gf4W(oJTa-M7KjFQ1)rbqpE?*H#Sws{b(-(z9s%pm6B5zE@|O+4+ael- zBOOhSW_gXf#wF(O^=kQBM!~bhHk_P{3a{>z^8Sm2f0>Kn>2UPTgfj^y(dk;Z zzo%!5QN!Bf#$dH$hkE*8{g-xZGSdNPvD(iW8f%Ynm_W!;wS6@is~Z}c?2+GUedgb# z__P^*t_5Is(9O=lU^Ji(BlKKYZK%1ldL8mla zs=jEq5)H(H2FwQf|6Eyr8WC__?YwxpZ%&f9PsSx_$y3OAr_gPfmtP;uQVP||)7a?G#55jL&a3;2;h)Y_tdup^FW#&tDk9?lc+#%_;|{w1 z{GwA);j%8c!&mTU!m`(9GCYcOa zJ3C|B+N)d{G4x9!g1MM-zRu&-hWttT@0FWAQT}OiK5;BVm}gAxvowR78{`NMWYL=% ztq%98l{Cj`TF};JCyHwav|WnY)VhP*6ic@_z?UO3@Fa;ug(1U(Xy{m~r2HV(+7*W!bo_{=R~wy^lgx1}!8F$c&NqoBA6&vKQvD$*ayp_IvpjhQckb++wEPQlmo9G8 ztma+iXjukn!Y?d@mCgNx8uYQHGk(7iZ4k_LfM_;H3*)4Z8SQJO`Y@4~C$$1mUp^5L zu@2vGkDh9K=LCWLD%RD$KL>u@-_~THjAZGl>FRR^idD_K)>yJnxZ62!ug;$Tecu*t zKCTkI$2?p`1P_1lM>4JNH)gki&TGGr2m1u+m$>fx<)~jkXR!WllxCMej})u>(^K!< zv1-r!$n-$Q-#F3^MSFU{8&{XxLJ3&O%VtvVI^0m=?~bM3?5Oku$hKci2Lu1CQhwiIiMwT+7H3Z%h1_$?Q;|l>pyoC}i76Cm2F1(m zIjF?lcCXJ(Knmt>YbTKIwU151(Xm;RwvN)AcPt+5O!>TY<%Oq#+t#0rV&%?&pT-tU8 z%F53lIN_p9a*w7zo^u-vstDXh+6gsFL{$QCmiu;FWoxECzRi|;_4ada=)bn5p?_qW z3(?`~?uswej-|I*4q8YFmq4)o1jB|LNtL3|8t~G|py64-(a-hgMcI$y$HKe?i4N0s ztxo%>p>=K~$g+a?>c3a?Ms}H3$WG$1Q&(36dLJm&6v|Vr@db&g*ZiMg&k``;%XV;! z|4Ec(SM|>^&lOK1jv9$~aL>5?#LkYRzmd)!Phf&WG?F#Nzx?US?0=>z(nh%Ul&wj6 zlx6v9%rxL9QgC>DDMHQ}^yH#V9Wh8L&4X4~9o4t4A<@!^j7E`2_ti*J%~~UW5_LY9 zriKr%FN&8bLx>NYS&mBl-npZYYsIR7m+MyGp7B|Kywo$ndE9-~Yjsz1Niy%G<)Ec~ z`4@IV?HDob;KKhUMKx%(%- z`d}!-PMzu9NJYg&$=7yKWd)4Hh|W6tDREu-nFib5j?TW(D&(vZ|KieY4919!yq}Us zon`nO)?1z`wdR;)1X6sSLO^7n&)9DVhE)BuIx4JBOoiDKHGuW=Fc;MZyd2Jr8xU{rdlB9}9 zcjoG*8ZxzPb%m`Jewe--YBA?OrRFsp`6|!q=KxzBdPS^e8Jgbn2`WbPAA74Uu(f6xaH}2c|8{TjBy}J57pwXZ%xBMb?bcYt@{zD@$1#I9-g*t0c;i^ct$$Mpj zI-8?+-uEN6T|-(_bFp=Dj!#8%MH(7uDT&=g*ly(LL;58Nx$~cnQQF_|KG#T&pb={ z?DqSFD}{*HE_Y2uTOS|hAlJTD&&6^tgn4oCI1jr24Gnn?#~rTK2rA8a>QP`;`Fo$0 z0D>IVnl^i)8xe(|U;V8BWl zt8hZILr_&Zs$7!0{Lj)-;KT79c{Ix4tj<0wM>;np0rB8Qo1U&~ zqkNP#r>GYu_C{QR#z^?BwSIxPME*2{7IB}HjGFyNGTV*tiSD0G4A~E+MpxGP$mu*o zdlGC{NugxO=umu7ubHv=_kP_bGU{)w>ZW`gCOj$W-GtVq4C%I5nz2V(STd-LL>^#; zFT?)pkLK-0&Mr=rS!H3CXye&5Y-|vSigCH3ppCR+bVOYTuJnFG$iMJ4-XA5E(ZOP) zdCU-COBRAmXtO}AY=i@Do_2a4&w_(5o|bOF_1I6G!FRCRwdehvW6vLYaUb%srbiW= zbzAwTVEwZvi@i;}1@&3GC=!8%F<0Px)4N5O&C5tPN>b2M+HKGsj45o^OY;;8|hd74gM~K{q(i-0n>}g%5zgCw{brMsH3e2EFvp zno!5fMmKcvi-Yes6?si5W@S#8@-fsxoJ zW45CP%->?1a>Z|>a90GjL(GIqfC(5Q# zGGZKE{aOl0*4aH?47y%~UH4wE_!}B-Z~Az%5=xGhPimA(}mD zwwa#T{Z^|JeEt}GNB!agTl8AQkxoxmD-TSzIl2|DE{`OR2iE#LRyZ#8v)l(^beWqz`x|sD$Tg(Wgc&324jWuk{S-Ov= z*@%(fN~>R#=Z!VmObRL^(a>P%bVJAETX+<9xy>wSA`)^5z$`!?6L|xS1PSL|!;^Dd z+#hz-*QLZ&(5Y+)gc>G7Z^j0-^}!%8*x*&~LnA=1tXu6qgYCIQRqGhYgnBP3(AJ)s z=`8y+?N8nxjH&Xpu(^_4#nZlqHJ<@mmaz+lj1+vIzSH#~<~o(-4>7 zYX{(ZfP?X(Qw;dU)tR z?M_;I*$Kam(sw^`l}MxW5ui)}wgW2xM+=Ad7u+SD!9XBS&JeeuxGemIZZKq6!bFAc z%SoENS^Pk@xje(=8uC$WNuFB0YW zI<5-4?Y(q#AHx=QZKY&(h%fIVCDr3$= z_0;k!!1zaD7oGM;O%8_a+U_Ud{KeiIP{QJR@^)iN({;99KM|v`JJ2kC)~Q`2pW?)+P&DxPrac(y@(i|bMF+JQc`EMR_i0X7 zzD*z05mDYf0bup`2%tQm_KR9l-R_wqP%onmbM6kSpPKR}70lOR@wp9YtWzUgi9;je zXF77I5yH)APnf2mM~e*-h7mc8qZQK$0t%^pOkP5@aJksVu~;0rWX6XG2zZroHV8&T z6}N8&C@SB(QYq5ex&{fE9+bb8!W=DmRm}bUTwPB<`GtQU(>Zjbnwy+NAhB-9s>Jan zE!=DSpjU#ADUW=+>4V=Hei?T3iW;Qsgikw47*)9*Z1YOaKVbgn{cmV&ZEY0~G+DfM zZ@p_ZeN2Ed0i2dxGnFeA!-&1+>>TpcqCUPSCCvNX{k(c47abpQ8}zV!7JSCJT>T7M z?7gOb9t?iDI9Q^79=^?LJI%Dt1+)Q~2H9Gj{2xa)H?Id9dZCG}V24pzmTl279-HG` zss05;6Fq3~Qkh8`Jzcy9I;C$Iw3H{m>acE8aEh;3T7F3{n}XtP!bIqZuH+GIMe(hg zQ7?I2Y?v*?^<|^QJ8Asdz8e)Jhik{fotdK&eT-p+uYMU(|QXBp#G&WKq>b!Llq;AD~Z!l z`9$1+y=6SEf3r$3Te2^wpvqH86g*ChD*156`ST9 z)Xk@-r(4+9;LBIocX1t$@@>Nj2)3D@pDSO`UWpeb45&)at^);M=bOH)yzH%)hl%^# zov%ONzI3|;Zm+!d3`aME(YNE*_nz5AC7Z5-S0kPEBH}@=N8kk0hZ}*g5Hy6O0x@mB zcPnd`#!T6mA0&fRjXGrPoY~kn#JRRC*04Q3@UT)q)yFZIC<{>Dkw!C!bupYdY8FZu zirwGs%j)dJGU-&6)*I$9h6>;EY@B0)NGu#QIPyaGO7og@NDts+4-XCT#t>#lQ^_Sq6JmTp!!(XM+=5*{=-a#*r?xm!+pj!) zg)k3}v1SWl%46rc7M+j%&FP8?%mPH0@oec4bD%%q1!YvVr31&CvF&JM)G%C@%CZ)_ zl@^j$S7QfyMBB2fV0?$@@cyuB?M0i!N1vQ@q@)2J#E6-we?otR-%OMy7rZ|7J)(t~ zI9IKOdEQ0c%Hqp@;qw(B_!bD;?7eO;_J@GIi3a4TyZyKK>MpMQYJRFw{iWV{T)!)G z@s{oNzCGPcc)svC3cl!lQtNulkrJD0um7Ci`*Pa@CGWl2fK@=}@Ecb0$9x?4JWoa5 z-_6ROTlj!ID=Mb#j03%1l4Jkkem2HQUIW;P7R=Gua#7yaZ%i)Aey988c7Qn*v7HOW zah!0fBWVxi!e!=OtEUROB<{V&5a_vHc4eya=&W3kMc<3}{vKj;O!qg02idlVpb|SV zb_jP5bN(GM4uvgb-o501_`}TUVx_*~WGZ>>28%e$t}8i-tq)6S6&w)(Je@at`JN7cv%v;g*ijn0 zDwbU(yPa=EO&7c%@f15w#+RxBvV|O3wer421#WNCQ+QDMNz}%dTN5%OfXjzqGEGA# zq!I$;S}CzsXy|#5+TlA3ctV}^|92QtI#{O>j=nvZy%V-l&?%HU+{ z(aD8i#sCTL>QbPmUwH!2@ct{$x+36w>gXg9;GLUL(WnHlesg(ixvlkQg(wd-yIQjD zI@w&U5-oQo@e^lN#b4J${&W$ay2aIpW6*W}5z3%BZ3jQG%Wsqv)Dw2hcW)C>08@z@ zQ-d{q4;WUejNEEV*qJ`J7^OMnN&MOBaU+KJ z2hYu`Q?w~~!$@6G$^bN+@jYm*>D44Sb6cp+iWtv>lU$E4yyD(q%nO`K=9v>}_`x*^ ztVw&=8S8h>RXXTwJGIY186ia^4a1)sCMj+(*`GVr56Qx5-0NtNj#@t%Wsu2%D-&=r zdAYlXLd%_Uqx$)i`B+l0fbT(P+?c zcwy`3>DkTkwHge*sBUbl*2%)}F?7*)8d&(TbyzX|Fc9!|5!m$du*c{4&Z9r;c3wR9To3A3z6C_n@<} z@Fq53oA-LpMJLX{06s5y*NMTLwC{2L;;Fc>(A)csfHw5ddff%T?gG_{BiX?j(`B1( zO*}+2QJfXhZ3cWr^s(O&aT~d9>=FFMnLSq{ZFNzBt_o%P5G{x__p0`4*wMB8=LlYi z^x|-G$cTHG4;MTqo&(|5WJ3?~r+4{o?u;<>1E_K+EMS}zhCz#uIh8n|< zl91x&@1_OXMV`T#;pfBr_?1b99ITv)9}V&0svi(!hq-E}r(fakBB$&d)fjl$R!cKpy z{A>#7W$q3JkeE|8^ECrPn3k%4s1W(VI}R( zXkN;FCGaJD(hrPy_#?^^CDZ*IxdV&&U*3;;`_*3jg+T2G~}wcV)ex!HVgL{5^8AmBKyXCMnV5! zn5c{xfk-eC`NKuT&>-n7q(bhWiuK=ku!#cQmuDW+s&^rXerFmi6+itu9XdSnJv!@> zM&8yOU4WcHwmkA5b!Gzi}h{51Ig4^d~~74;Xbed+ERNR|^F4>NRg|LRG(lfAytx8 z*atr7Sb~I}{lCAbJolM~+C&@r;0CK0opSv+5U3*4udRbb@0I7LSL+U=+jQ4;R#mp| zi|!kx0y$BM(xFAvAa7hSksnDAeG&;LvYKhenB%(WczY4$&9vS@fWM^1?V1-D_1(BV zSl4V)!(*L$uLCKjgb7~T*^UQ^CW%>Xas4{g93VL&(hZSFY*f@|lT=EB6FZBRqj>Qj zsqv-*<+`KcIxlkyVc5HF%$~Te^)1{{$K||;%QaFM{hz6@>YH#$1AjD;No0yl-d7E0 z#Y(-HHx?Hid@jx6d<-K}!4C!7>$`ugwC=h-a9ap4>x*87&B3)Ufxv zde~96oW;jSR|)xhR{rVS{*!iH)&0%M$uaHYyorUFf5<)vjPH`e6y4BKr%=RGObWAp zrm5g881*YJ%xA&Xj2MJ=%od-U3Miyy;11JJ0sE8OBkip+%u4Yd_rEYMfT+&av1DicT&*@* z`0**Xqs}T!nq;P~S~K6+ZZe#eLq=1nuyM9?b`NKweIjJcsbp0+ulU8#kt>8H(N5s4E9l?KJ9o0dKBov{bIzO28>sz3IeBdGuIZ>zJZBw6pB<~ zg`rV6Xz9iJEY)P{&yC7<=CKT{54}}|nl;R~7`H*8Jw25s_O)%>#T)lJrCh1_=&biv z!VNAvt=F=-Ax;HhTwM~Aj;|}K-fPM!nG!CZS+ZkAPinaJqV*d_%9v9yXcf_yMs8PU zI*jJ_k}F^qs{fPS%}!q$z{0L1L?v)ftke0j$X{4kE@G%yy>P>9bXRZe{B)Gq#uD>p zCGe#D`Ipq)CjqLbVuWb6*byATJ7@$HlXx0@zNKq(xw&5WxYB*Em_hn{|J?U{hOzQ| z5knWuNU5&#`1N^e^t91_ym=4a9e7js{mjQGLq{bRIsEFihgt8)@Jh!~ zSLGL1wbMIGLqr1ZNPE^!ur7n$y|EnsLxr3LEqZe{bG37aaofBzM(1X)D9&qQdx{?s z>y?;Z7px7|Nnf`b?{yCKurF{{Im6vknZd&!K6QxEp0>GuCrTi5-^}EQ_Gn3Ct%|lb zH;fZA!6pJaf{k=`XcGtpA|2#{-FOWBjAUJQ_7z`uLe#{+nDRnt-QmU;N^Li z7qLvP&}}qA%XwXa;IhDNAHT*BTFXgEg9)&I{eNX z4OEWR3e+k(%ycXaYU7jDL1ap0m^%k*IWKLk0Hjtt{q=>;Y?7)9$uNl`$=DZqj+bbq zU}Go^#Y;&w0)gq4R#}!?U&NdKe?rObfjui|c%D>Nj!Vgq4mWx8A zD9GA%tJuaK4|9;vR{`Rl=gdz=8CUg>!}X8F&zqmTA9n*X>|pa}UI&|-S$ugE5nFfu zMs3Q%YLi`n1RtMk^t7SC{Ke{nzlR8YahIx;bejxFJB~r$7^gE#NtOUzUvdJ1byffa-pr~CgEtE2qiWCDnSLm*JO$<^=R1hYY1P+0g5nq*Q6VAfJ|#owTxW4;9ne zYLT@{?+%V}%A>59Y&`cvzI1W1_Z7SeqLdgSx+4H){GuEHG2wP+5<2!#cvtdUN+vfL z09THXlsJrSuM-bi(Ha73^z4ns_US?1k>Pg`?%&tILvI(hGpT11hy#J|Iuh;R?<`ey z5CMt*InBHpTwG$oAKuf&`Y!h#i|jPm9^Z_;u1;m(McAql!LnAwd-OV z{gyQFmL91Q-*g!kR3IBQTj!7OyGAC_l)94Ff~rITX3Y08huev`+; zxgpJ-=RW6{m|A2#EZ^{D$|GG^R6%h04xT;x7s6dSq2fVXlSv4XJF zGQ2pF2q6E9F>?CNZwc6zsJvh@X-mR*SMCpcBqQN;u3Ih?;9n-S?KI5RgobO5#=>8A zWO{YL&YD7nN$!e9AP~egc4pbjZtAZkrGURmRC?nLXS1Xm+u?Oe^CmX~agx0fmqOAG zrq0p?#8%XFOr@+$WMadL7;||(rcgV968NRI zj6=2N^7HBJr>ohJjd$Pgj|qBS1Gt-NTn=`|zups^e1q9{299Pe6!r;>3eeeb20A2~FkbVxmmFd%ml6SW=wN2{<;P0dlxr`h zf%njyy8{TusBJ{R&b(jnFgM9XtZ6AgXyb8((54qIQOI_}r}X@E)|IZq@{-I8Bhg)pK=+SzTy{}$F) zBab2n@y<|w!(`ZcIQ(X+A0a3*zhK5S(oqRwqTDt;l?LBr7*nX7hNIy)d+@}CFFnWq zP5Q$>1KkTnq&3KTEMLW-1&HY|#HD_vtFYGM-PSVnDGej} zs-wf*@91_f?d#jwu_Vo|#yDd2DO~i3IcrH8O@%507qO+e+dv`9T$ft*jf*L|oH>U)vhTLO+UUw^8WnfB>eEX|jt$kFIO2e6E=|fxR ziM_HDiQ!e67Y6f>^7cSxOU5#SD@yr1b9pp_lCG++R*+8fy*qy~4hXEzeQJ74P>+xC z*2u^r@R4)yVzR-MC4AD=S^REk5+eESf;`ljz`?K0aoKKtzn6~= zPTI*uFq}sJrLz0>0{H^FAc;aUCS(XNSEiB_#U=ZI%as2e7{^9!*1J!pFmX-AgW;Vw zt3Is6c=pShA{%8_K?8e!z=7;+X@c9jUza#tIP;<`8;adfuL%0bH(AnLk%G9QZt9zS%x9Zw zlR74xQ5m090{FL{d0?bGhr@4@5zD;+S+IK^Zc|ty^9Xo^(DHE@pgOe}IF8m&LS_9z zrPMOPeXNyljUV5t@gqJedt@K-OY)PKI+1KKUuvTLPzNmW%xvvH>H%o8#DOFj{+TvVK8OM){jACW~jRtwBi**Y?hV05w&=i z7sIeLHw9MI1D$NtD?L=?c)tP41a2HSwKbL}VFn?KC5XSDN7BIg$Ja7F*+5phWZ-H9 zCb$V`hucePcyeQ9_`pMF$s=dk60eW8D5m+%M(cEK?MqxEq<-{$m?7W;;p!9vZc}`L z5=wZUVg3s`{#RpthOK~yF0ZR8#CJ;kAK!%AaZweJ2g?z}q@&{OGV6_moqYfF7#RrU zFG$aUM3i!DLN0#+t;~5@rzz_b@u64_o0Z5Z7;{6Tg2B3csCLjBx_YqERnM z;?sAU_78^jY2o0ESpQ5U7&AhIF7kH9pcO0ezp-(VF>QouwyhdzXFD@7&>kO0&rFM!nJ|zWz*0f<>U7bT?AL3Y8s2Ro527 z05)tJyrj6%{JLedH1*QokTwPj>Pc{tJTYjM7?|1e$WSo`h4YBY=xIV_hED-XQ=d_$ z0i%|dgiYENTe~;af@mcfReu>L zLu!p3tNb^p&`;$>yPTWK4=YK92PotJDMUOaj{8=Qj$lu3Gq|@Ise-<~3cKO7z%a_8 z(x90$CLL;8g7!!7jfOIsdsJh?r(f$DBDjCTBVtBS8DI<~(b~HpEX@}OQ$R);4m9OQ zBHIUP9zsD{kkdFBodDA+INkStywR7B(o^GSYa}or99%a{V$?T2WVONk)nCL|_WyFFY|% z73=xUF){S?Ehen}r{()>9NJ5!D7`X2VU(*SEipnV3n1W(+&GaR+YUx3rmf88MH*#8 zg`tf`Q*hezqpy^v4i)lTsLFXm6aIz1X3v?4o`I8`sh=1}Ndd%nXdUjpeyCuG{ur}b z+xHO-#ug#_p1@w_Y!~I(=Re@(zqD8(m+Dwyb+9Br8Wh0A;jjQ-_{Kb5Se#g-g}G4v zwaq(?4T;1*PLr68$-xZAWIiEIzJ2uo;xWdD<;ZO|`$4^2!*?tiK=<=Ufh!WRZA*ka zTmT-4&s_lK^_daB%T`_{R#ntp5ayL3`s;*v?&astz9a5@=6WKqp3&pX_ zW@|?R1eYQBcY1*TE z8*I;SrFF)&A!si14{$ZVt!39H+O4?iI1ANLR zT?s(?LCymASHYj~iKKTfucqX+;6{ea0+px<;t?DldKKEa#&@b8ALZWuy#Q%_aWV4M z)EFBZo>$(A;tj(bYEr`{m#5*U&n_{=&SHC^fJp_*(awncc0z}Pf~pR9KsmgVVib_ND^VuCW#>d3Z`i5+I0g=*U8e{L9=WIn^ z;wxTkJ)CW@#t$q80tTzo8EF)cRM->wyv=ZiwlDlK8AdK158ghfAvgg+S+6rkemhup zo%PoZ&s?MpHZo=5Vt*Og+~>LZG9xw39dvxayUrDjs-;I5+x|dm7|I7-G@gWL^?=J% zl#b^u{&xV+nFwn|d(Y$wsQZjeuwWs0O-DKEBSE!8WXLh9# zs%`dug~x=4rMap!FyC<%?M?yI17ZMr$*EtXDF^2UfM{ssV=DHf{X zhg5{kg8F~(g%kGI0wUwc7#v5Uo*o{D zro8B%liPeC7M+1N+eg$fZ$27-%*)RcHtTL~`{d_$JF;^3rSA9OAS>(m_(9b{M-rhh zO_Jp>(#FKoG(g2Mr%ag?Y&5o=2%pai0{(3N;4Ge9yQAL<>1Qzlm8q2KU^+wy<|V1M z9+O1zxZ02jGK9tZu@IgN>MT6V=2L|m|4_1oi_qDE zoHpq96h9lh8PAuBkol;BkG+N<4#9aZ4BcWmG0BQ>dfW@$>%wHQ6)X5BWPakLN(-U1 zgqObDrn~^iUmA(?!x`lYW<*G;UoL84tykK?jjX_Jc>uqJHe(>h5s1yZ@=^;0TG`Ta zmZP&5=O#a2V7Z9wW##SCR@CeC$sI_1(9f>sH%*W7|TAcX!D1V{$Xs{dL=S2`iyq0%h}xH9#FQ% zMn$;Xj)qc2%zeWPdpA0R-U%kGkT;R53^9tmAGKd{deClY;kqQ~b2%@Z7bm}z)=Ebd zp@oRGpVG>amY`1$d#uSXB}Dy0sF1tw=4pTST4{Z%Z6e+0<0=hzb{0Bv$P-MDlou^@ zs!p?>n6`5hj%pkrjpoAaC9ZTp<~Hx%-G6`LP>&U0#0?YE%^sGHCE*1?wR1FM4ixsV z%x3WTlJub5>QF5A4Azitpf=V9$53=#U8_|W!uS)}STZF^2I4f^*B}|!vo1)_b{i7? zDH0BVUT$HWZG`6R$8YN(X3^~bqk^eaQVgQW#tzx?zf1z|ym95y^w+7dP9eQ&q9ltL zauENCz0~`oNzaakYCDB%XwqGj2Hyk^OVZouS0;|iH&$1(H{grs^QTW=>?fv`FcsKi zgugaM*v~r96+AnR{t1i2g3m)--uA5_yx<*9`(;L48f_yzNoYu`@WKL5rwEkx3Itg{m3gOW1LqgWm9!!$W!#%f}%_h8cXemwS z7$JKVmmaq{w0HP$d3m|Hi6{j$ctPN$7e?=poTyh%k*v9POHjY`A{#e|YT&&}(mp_o zNnjqMJW4nl6Hvg3{mj4K?s(KCTI-UzZA5)pWQsNbnHJ=UH#0B3XWF0#F|RkKt^nXGnz~bfNwLvIJe8SaHb?;xFWyo46}bP9 zkunnTk?aO~%KRVp+RQS+v6j6wWqsU1lC5kbPQXXPf_seoL%*w8r?-zsPhM?@!ADI9 zI83c*$ZZ%{Sq<0CEUPpJd=yo0Rny(y^MI_X?ABH1uqZc4&r4_PDNlKgQJw^w&2p%( z))X{*&-lPG0j@BxZ`j1F>q;v_LcaR@k*IWH7LKg=LPv(%0c%&aL4Whwku%;K+)1l- zrIk#PvtTk8)9q`N7d-v-&p|DMs}q%DSdPO@ z;PIWv+lUAh*`FTT#?EMJ^lpy}aYyntjjmv!RRv6Bl>n6FcQl<(yYsOx zJd$Dmg|B%me=IkJOWhZs4>bW|g{6i5`N~%Jyn%^|L7POshb378M5SVpUtPgQbiV(b zT0DjTHgwKF*dK(CyVfA)9)pRw&2`0`2R?o49P_4W<>&LE=F_yW=s0?{|I9RPsTUB8 z`&m1u%rQ@yJ>t{yZW5X>8}RTm@T z-HF!%sm#hgUK=n=USLPa(Q*WaqronZYmTQwh!fbXeilAYxM(e+NvceOUfO4|?7RD= zq>?_OnHL5ye!eN~a<@c|V*QUbj2^+aBd)BM1MNqz6|&JH$hDhWTNBy=gPOTiX<9h< zbwTvvv8`C{e#qt1vN^inOl=0keobTwS#fQM8%mkfQP?+o7&+DE78GraCu?5MKyTeZ zW$bo^t{jT(gz3Ge4#=KKt=@2c)mi-mvCP;XCD!2{EQyYswW?zp!vXM?co6=%DM6>~ zkhu1uzFQ(3=u9KX9rfEjQg%=mU5=3cL+^K7#G5SYpO^hSY_M=(tbJo+qg*q8xx?Gp znV&51oYUgIs#a8Y!MEoreyd76&}UfW(@|^Zc%B63J7<`D-VWjh_0RJ)v#mY*jaSF`&7{tHZn_SZ3}%Z0 zG0gL*AjJp+(;|J7-;NP;D1zob<X* z&_oHoktCm({OvYLm1{rX)g+Xwfl<76C&F|*{(j3zU()|N-NWaib-{PVPq(taSL0z| zQZf?Z_D1IOPi5mtPf38r^~clg#HXxYaC_5dOZu>5H!vMv1X$L63}Ql@b(jzP(8l$5 z+C+@zxr86Tp+0<6asm2!8Kuq3S@`JGfx{bNn55!ACQ!#6=;4F}uYRG*zm(z6a9jKK zA?V#3vv+XP;Y=f~N%uN-O1$V|Wf`3u0ur8V;b^`LmiBcow_I_LF_F^)Lt&)S>kVPMq^G@za`YG=jAeyU|&KSTGjGd2O{}FcxZ(bt?7KE{nzU=8DFj5q3_+g4!t#33_``bH*MK)I6y+YW>Ew)e$C+;cb z3u+=LDL?n?eMJRmF~`p6AiT%`lxppd zu%{-}a!<3ys)-OA+fbimuR5l>(jDuP=ZOcDC39w@%U;=v7eGnp=rwUPP~FexrYM=K z4onZaG%fWa^w_uhS%(RsdTW)#7@PEVvSj98!Jn~6N_bp!RTl!5KKH7;EwRLJ8nE6) z6_IlXQJb=d72{VxVc#hb9Y^?o75gfSv}(pIgP_HgHLVt5?Al-*d{e(<8`-Ab+}tW; z@tTRuNXN9(Q$pG~|8(cmr9Hp?e6~Is=PeR#0*s`W?ZY)rRqNPiy>~~~V|r{ouBu~} ze8ESn0hm^TFDVp$3;uFyJx7NhD+p^bj(}tsFVgJo5os_iv@e4Uk;#&N&qr-5Z0GD; z?`YL5wj(JV&1YRx@Vc1A-2j7V@kVqPS=L{3|L9^=eclL;Wh%I&yuP5^O1PNw;QKjw zac5c@r_$7=6jd}hIOwhGA@jD_YStSOy%rG{PuD>kFHt(*vup&@N(CF}&v=Q~!kMv< z%OvHhH1}JWM{6 z2|EgE`Orm=No4T}2);jE)ngn)65e-WxJ>z-jE|2a>UlvPXNccpisAY0Q?Y(KOTw_h zjf>)xARfaHq;S`H$nrakzOLOelEVHz`|;T3O0{tBh_hG(yk9K|pCDf{5DqyCFmvzq zw*T6}`PtgnHvskiQVRg z;OL1)mt@_N-J+MbX6WFv+GMNP91aZ)d5JD9XXB$sgjn_#4-x>#6toi*H~x4C8aj_O znPyg3Re_jNi9b`)Q^fSb#9HX17QX`3k<5w4@PVpbqo|tgdVDg~X7!n2Zh4#XrQlR+ z{$IpnDE<$Zx0jc95y_GcvpdBJ$0wROJ_>5HMkLjR%y{frh@UTrSY%1q*L8*abEQq) zd5bOzEQ-*aP`Drng!|bv!C~3UO1R$P;Qe@>!Hn98i?)l%@X-XT7byL?)j5XX2GQ>(~nXCTPiTR-o`IvrDSc9(5X?WzZw5(d%y^S+&CFypK@8Y98I~;R5*xOiiZAJskC~d;q{PPH!BHi9glu&R}2*`$~Tie@rD(Mat z6ogMcz2g!}dM0Sa<9bTQ;wb^Kr%jUBB!2ffQkvJ&j5u8Pw-CZtJ!2glB8g}Ooe!=rFQ=(FBMrGTo9DO) zL0gVR{3lCubCjh}^g+}W#BYA7Fr6num5r8V^KQ!C_(06}I03d15fMQk`S^!kKSTd6g6_f6tp57?8Ugb#A?@p^O=#r!@-83&)@T~sqy@GQYTcL^c&xU;HeUqs z(%@%@h7G$DBGKZO$u^{=kuck$2+V>6)vKF~>Sv*UhipOR*?fq1!x7z~%7E_;q%wvQ z?TpzRVbvQ6Rby7t0Y&0a#5N}B@=#tamm39mKL1_PhWqJ2Y+Ft9B|_Yup|2PaeT0N^ zQ1@sAPfXNl9c?m3UgVe|#?=q=zJ@o0;Vh9yMR6Hz#T~*Cn6>9_$q$*NE#x!t66ycK5*tmNGBWr&N9Wi3K4nhqnDL~ z4c!h+;K@jnn!i&pP*Oz0E{EAjSLOpRrTR6*7x8E6+*wCriuYN27Q&GVy)QF!c5ZQX zag!aQeq*sPA8uYcG5a%X$o6s-8j+T^0jW*n`gQTJYWWe!Rj_F(INWnpt9ktC;rHN4 z@c9ty#@X$=^RB9@8YPkPy#6S^8oF;CG|%CFtMw%dJ|V&;^|Qrimb}r+Z^vZG$w~#s zFRaWF?a%vZefdhN!&IvNTX>=?)sk^N_ua3R2X*D4hfPNjDdo6!_ZIco<%I=o!O?e! z|HP_cNGm7YgH>5Q||U$mb)uP z8bj*onKU%&Mk`<`**Dra{1zwqKcM)37-qtblroMnLV9J;WemF6!ak(h;L8llPBw9q z`7Bp?1k(+ii0*y4J$!!8wkeAnk&!IDJUu-9&IL8%A|~%p`tvvt+{*kjdlvH+s0}Am4Cg!=Go1+aI+Txkus*(O4gm z96NvLFvRLqRRIdce_i}`D5+pwvSr&l2Hp>UZ3{nPDHb1^s;bJYZmLY2>GzgtgZOMN zUX*c*6+4dXLmYG7i{^5C8GEmoX(y2%RrTR3v$spn7iJR=F3fVD28rv0j#Vq!unYGf z>M<6?j>&)H0iBg@sp~N;UhhBc9d!&A4*CQay_6%7VBBbM(@an!nEPv!q?kyimPa*l zHh=Gz6eAFRyo`NE-NA4ZZaOBkWd`0k_u(3fLFZ+Lp{&Apw*7FpdAsR9>s>rl!uA>J z@U64+e&(_M`1pg6%N*ng3We_7W%F$##B#|1_tunly4jlvqut?->v#>^9>1GFdwW)` z03RP=Dm<%tQz8ZdnBlC3tnRo-%$hN%FTuT2#@G{)MFmcrwcq88`sFVxU&r`YSjSQwwq$( zbF0J`RV?fm<-MsJC?p_CV7mnsg>%}YQE2zuRY)5l&U*9Q-Ox~6n=9f=D}zFm!f!&d z?5Flx@>QkTb6pchJoHHiuDx^&oDaBuYh|x?m-14G;43D*Bdh1aSMwnxkY*&e0STZX z$vZE+KcZD$kP%fvuMAatS9UCMHhuqR^DWUSDk`=M(X8veJNCv5QHilH1c@ry$2oe;h^xIXp*dw3Ur|1Apd?0Q zYKTJfi<;9usByDl!U4?qg1}L3uk0IZNVQe4`kjRrV_n79TbbH*O^TE?4(r zPJ$QH)idl=O6~3K53Y1n=2Rf2zpBx<(Qj(S3nBU*Hlt3hjFFG4fh)<)_+Za5Ka7Rv zgHq24Ub@60ySvX3NT}35 zan+-vjEOivNEVJSefK+Dg+wGoUN;4$P^3>nEmys6hGOVw>FDTQzC1oU@;mW`K;pUT zzv{eEM5J(XHDI#6SaSNcR>_~5m`e{kSVoA;SEB$?)2|#bNG)aq352M|VD=3PEadUo z=aB!15go$jv#o8vjO*Wq(;mA*TQ)uHazqXJX@{?{=cQ{YMrML!!X5kt#J(7TC@48; z0(XwY@vwnSK?ruj(BTIjkv1IzeE}&8Efs=me0|3GIx#URzWLi#G&@;L3VMceO|_20Ijp0P zmIJslD2M%GKV5HToR%O*12op;ifLBHwt*NJVq#*5J`fWsG9F)4li5h&XxgD;*stRt zcUfxJl&&+@o~~t6yI4J?{9TKo^S~boC?(yY5hcxr zi(oiPp%TZ4+B?!4A=^+Qm<6-U$~3WVLM&lKSh!8e1(sqBtCR`o4GC2Hq6%K!;x6#g z2W)S{700CB zeM76cZ5F1yA~l; zQ6++y_+Xdb`138MO`K$~ye4T%8oYkO?VT5CKXux>1(xRX+*lZRtUUz5;M~51wX!O- zjpgj8DJ9||%4V|zOKiar&sgl5E0-l{O$NVmamZ;HLG4F5)I=~~O>n|e#GT3TSZu#j zyBA#h6)w8qpA#$Za&)*TxhMv}^I=`@D$Izga^5ay?J(C>NwfX|@Zupxn0W|)LvkJW zdH6H**6w4=6)#<1&a4)$~e1 zA7G z4~?44MY!^C<#C68`*g>`(h^;nKd(8eMr|A1js5d)w{COdLfL{QrS<~RC&7c&IGiM2 zWjjn-n&s0T0ru-x3je!}dbihZjjQGUvY$_}WVKQyVJ0C(P`O{PW~m5Vuf8Pe!km^n zWwv1KoEt?ZK$233PYF!NKxw}U-q!$C_C*vk{*o&g%Z59gFt}IL|JnlgIm%+54mUna zjqYQQ8Bzm;@b^O{th~+a74qyO#^A4cD6x~~>?~h2kA@_vAFsJ7tp*i4uWp7Z=UrdH zXOmsom&JCDMCM(Ixz_Enz1+Nn+*8;(CfPT^xao^Rzv0b3DZKCB2F zcX7JHyzRy~`3hgV>JU!zx1% z*0lEQC)X#tSLKq)n3{-{A^$h0ezUNbj6;8?z^~#k>z(`(v94w*?}Kkq@HqlcctZ!4 z5X&Fm9y|YIg-J!utjrI<#XP&XTa=Ze$57W0(N>m4qgIb@b6uKWk#fj!Z3n+5$C*9p z>@yJcgd%1UPa+hi4Nq8!u91$gg$*%Z^ZP4{=foi14xb~KNB3?AJt%V!xqpi$3N=Awfy^fhzNPiE_H|v1F&pu}45+K|6|sGo-ji;eAktO+vYpKs znXN%>qe&kBjOa#?KF%4z@4tJuE@|XTrrA!)trn%z)Bg(G3XfGh(bt9&Ykz)FK$1!I zkU2wP15~kbU}Ix)aCj)BFcL*+>0mmhDVODmc+bu(Uq6eVc)s7Vh4piVJFP8?!HCKa$)=45Fa7ZFGXaS=ta{qC$unI5AO?!|SqPb&>i$UL4W;^oK5RxS@De9s_8tnrG&>8a(Af57y(kh)~ET(Tw zXx3C$|7v=4kvY?JGI!srGxut3m_0fB70e#h&E@8$vkTQ=EjcD3kxpSOM}Uyl$9*oQ z4`ixCQ(TU1%}$^`VqpeFXa&h48iTr><}YjwbE!of4Uw=tHWfklXrsP3j}DNj(s2#P zen;dlY-&d-J3QSJ0K(f-sSs)fZUM^wu2%-ZGGm_a#B-+ zapUkliE1#1U0}x>q3)C&pPK2ljmPY}_Fnl7_hU6$BA#`5CibmfDptxr@+Q@*itM5? zKY*DZNh5h==n4OLMApzFKB|(y<+|!p!|eg4&=_7!U#ZO?B7raFQhPP~QN-=wo$JHC zU$EdzHgW3Vz>tF=5`_T!EF6wr90GT3HLg__Ih#34u6pvtcO@JquO80MxItB*eV)u`_oo%uG^l@kj@O z*+v(QDK(Oz^gEGwUSbQXZOo4zbzXabZ$X2tP=q_<`l_@a{P_HM`VT0GR~ug9nA6%> z4E@8*mvBRvwM1+L_vz>5uiTHCt7DLzp3WM6`%e*>NP*={w-5krNB%}KxOr|Wi4G>38mrP57~Ic zxBZ|lYw+K(rBUZiTnQCdiv&K?gv_{3Ox9SFCK zdtt++l|?Z*oX%-Q`@m3K;7aOA#0SM31-RsYWgS+cj8`%)XB$N@iOG^N2y)7`F0Svp z$(^rz_D_644AE@`5&bsVS}G$&@Xro*E~xkYvY53p8$UaYzw*1ZQnulqlb@QzZU8l` zQw)WM0eGG=$mr*-k@~z+MJ2TOC^vx;YiMRtt5?sk+s!J=2YOxulVp0sZH4Mu{7J?23e8()6da%0ID@!=x=yRIK8qo$+wcP;m!fcecU6 z+uqC`!^9CinC?;Kv(H+o?vkVR(Ej9KA&Z{EQGFwdf*BH=;k6S$W|Almsx~RayZSR> zRl1Rh2`2|Yq*uHju{3-`bkT!-1LlS6OD$~|bD^A#!y(#zeJl}peY_+lB(&ASuFsy< zsfMln=dTObNbD8SVeT{R!&}VhmowPn#Gi|X<8>Ur>=5F!Dz8%z_?1sp9qjSHexM;l z)DSFaS1Y87qdpdUtw~elL0D9eVcD3@y~ zEw}9meCB^|#y^zZeRq0+Y zWj&OayM!UW8)knbQk_NGw&=I8KkUZO^Pd=Vt(7$}TLz)xxG=BE|5CNhYAhH3i$eQ$$Sw+L-^-3ih zeb(LdnTQU!N4E`Nx(lLRLNj@RyZ$?QLQ=oHmk%I#<EMwf8gXumL_BdR87kKPj)mg+h8zh63A!6qvJ@o2kCUkm?sH0rU==HS_Ge>d zX9M|0+i>3O2-FW|21yQMlL-!p7=+1%`Lu|Apl|xS0}KML*Dv`$$gZdEWnSepSH@Op zzfDOR)qSa*YqEu?+vn6%#$l3^u)EGFn)w|q>UKRp7eqTzEBC+kK@kmwm1oSd0jxqf zt}%YJ+!**bRaZ4$wQVVA6-MovLwe`&=@*9>AQ2jr0Kh>KCy~V*0=k0*Vz0c_(KJCy zl(kL+0OwZYjN3o+lT}qhrsz-2V;_$_6e)N3iQ$e%OBgk@iHgW@8yjckyd7m^PNasb zuUd<&(V}l+59I*yct|G}p^!n=@-^B`>U04YwNj_8E1fjpw)h5!s3#S?>0bwH=TlUf zJGhEWaU%~(Ai$PQ=Xc|a*keNHe`d`MwZepDQz42k4pCFMG(DkoR=PHVgUj&e^3n^$gyVTZl#EKU z06AK0bh&{<(N-$e3ctmt%_mhbC+AJj)gv6D9>TkM#V)E0QmM`&VPV{9^MkIdx`7XG zmQe5nI3+VDGN=x^pgb?|9W_P#EmAbxknf=?)`g!@S$&^gy}?klTFVL9(zTN{ zF*`pPQ16kGY4?3oEt0yAs3!bo>IQs2r3eE^jPMo~Fl22u2|g2}_h|<;j7G*i3{p0v zNuw7kVR++N%HrKf)9ijg9_VtxKNu%o7PKNsHB7>8=AJGmfq1jJuD$rByLR`qVJhD7 z&E+CGr#8|+!`9Um4EA!RC^b{Ewh{UmM4!%ROtnE(S!*dbQBhA`3!&Sl;hne(l?W+h zI<j`V>q*ncFf&a0^+J=;t^`j5&;uT%C(l=h)UwNId#5*u&d11g*)*5@RIQJRJa&t z#QbYjJZRd-g!k%u!;~FVr*d!Y-By$g^d&~VUl)ss@hurGAr@LQV@p=8-2=L0eSK@H zrwqONU61DdGsY(qT`zdQ@SCQRMKL=mtso@TodzL;m@Q2~45)O>xvHw$(n#05&Ti-k z30iP3C5tU45=PW2&<*Q_$jBYYFuq_?F6$%o8E#hM#V@gmHQiIWv-P_hT*+fB#TCWo z(ZIpEH-J})EllE}a@fWv7r>+2qggI-8D4N?p8&;m*#tLiIlTh-`0!C=S$oTG;&!=@ z$I4fT529siz6~NEY5NO@UzrQXx)ZFs?x>ev_dVeoJh{XNBg3lOxj_!oh7>v5=m`!ukV)8m_YGWF;rf_|%h@HSe!C z0}lvkx6{cf8fNDcj=}=KemMmkFkHv0O{Za`UA9W3^#t+p>`Su`+{VSv7f6!@ml8KV z<9nJ=dE6|GFYWJ1uL3MI(WAsA3D!$yO(f0(kruspJkL~I2(k>pamgbe{2co{atZ)j zt*Fn<%pChp_eMNiz24W$_HzT0YE9o~Hi!Jkag z#rO$({)^eTlAO+A(a99FxU^&p)|&dU!!|>+pTo9W-3(-Fbb5{J7Oj`Yrt^L&bHrG_ zoIX&+Q)EWQzQ4(ruCxm{7Fm~CzM>Dw{k-k zoo-5d?)IgYEzvgA^DTM7OlZ8Q_I+}shc)!7`O-A7+ewPYRRuE6%xYatE4YSZh8H;t zld4p;o0`wG_Y|St?~yERU8BGCwXwwc=f+i}5wZoITW2s`k;An9mqz1LvfPgJK}_Vm zHe~vDuTf#W7yiObSU2nsER4OkJx=THzpr0*{o(!nXQlbh&wg!ocD5+UkCwYFl2uOn zEA}aKEe2~10&841{X6zB$`dvMqD<1szQtg6iv%?&>^iKn7h<#oscEvYGJ*{XM_G~e zDiFT(XB8>zBkMK6?l$*gXHnPsjPX;dRPbw|41#O2SdSxqciX+Qv$4Cq{kRkca8WWI zae?X8VF-v26)1M|vV_&ax$xu~FnsbW!4r8$Gwyl~AKWj6BiJM2uI*o0V*M2$QzW#b ze9dlCKBJQ>Aw}9xGSrIfoo0dBMY`0Ro8S0aE~PmO8@4ZOs_b=tDQ{bZIDAGlh_I*D zBgKx~y!E0-+NB~%)~{C|GS4~ThY(rwMQ1xdFIW0@IuFg1#s#Nq?`%e|n^<^J&BRzc zMG~kq`^IzzaXZS{6M-7X0Oh9Al680JCqvQ`rcsF$NL10AlRaM)h9^sYl`~_)4Za^T z5oaK%`TdP*$nvj-g-5@X$ z>B#6}^DL;Jzg92Rkk~f#4fjM#V@H*C&D@C>9lMisO0sHFBPE?LxXSX+klyqUJ{7Qe z2_(&XH4tB3X9uR6QZV+t)37+QKD8;ZW4**I8tClx_V;z)*e{b8UIcs!TnA>QtC_jE z+Pfphp$JSnS%x?j5V*=v1B9C|^1XSSmQ}*N9pEA$-D~NdPkJBGvN;oF21y%$!+#CecLi7l+S@M?&15kc zE11mjWQlj$xach?LY63wFr}yV{alUkrRXZ@UsC^E@*w|4`DDqeewm`Y z@s-L=S^kn}6;n1Vh(p0u+l2lt6xDdSxOqYQp!qY0M@i*Qac;(p4i49YlPV4h@#*b8Q@m#0Z}I3t#1SbLtX=voraTLn`vg z(9q;!gH2KFytJY~7|8u@aGt0X+u@1%_>AOOgrBy9<6?=Y=aHnt=V|SZ_?@QY>QzVi zD0|pgI%iebY+HGGE)SxG-o%u5en*NiK9yN~((#qaxisg-`~2m%xsETC?HJ-dxH6C# zv3nf*G_#_jmEU~j5EpfLn4TNmP<;&5>i_CHLRu_Cz%Je>4#6xmab3dO%kBaNi@tL=+Oh#o@mFs4k&FUn5XkYtJ+I>3+m9neoOf**x z)#6L^gZSQRcQ6Iso8Sq@Y~)eUV0{E#n#9{?j{tSCnuEIHiOXV06*-i<>+3bGW+X!v zprF)h(Kq6~KZ3X%-}_>V0F@H~f`?`RM>Llr-9K`zVQdoy(Za+=ULn*7*yaM#<}XLB zpz$M)L-Y!zX030vMAQ2vFHSdlCH@T8m@h>Vn=9R2tGT(<(2x6#CN=R@RX48Z*6jLO zL+fFQW6|C5X*|x($olDu$r_sYnH?ahdJs$QmW zY~3TKKl^^S?^97cAh6qJ6-J&lbHAwt^2||aX-g8H$b)(@Qw5%ZSqXkB-vM;x|5e%k~4W(hI?qN;!uF zI`dmzTPMe9LL-#Dq00k+w!O5hspf-AH9kJR2>>gLEI%Ti8g0B2ja`jn7} zqlY~|>#o)Sy=EK>C3a3OYH0AJGf>;Lctt~*L;nWX#OXs!(fTC7Mt{ATm}P1>Wt8oc zroDs1%2}JJ7PM)GU2sut^J3YZ>-k4ff$bynv==O=yVehu592@31R&_v`g*ZCa=c zjRRHg`wdox>%)Y1J1>ovjQE6vL!Pa-M-YY))@fujg=8@I%gfDwm=3(_1?VrazoCsJ zqqBBX!TC7NiSk8fS$}#hs({O_ZI2^k5H^c1&>iU+|F$N>ZtFtGIto-Rd)d1K ze-w?m38cg}uBV75ua<3lru_;?*Svc61t|xxRV*`mY3|fyqE4gXh}()2k!eh>Z0U0P zN)3c7fgOi`h+|yEo|OK?g`wk>UNGW?tBwEI3LthR-PR00U(#nDQfz0T>~9u#-TKN# zyJP*xtwq&&#`u-viEU$uHISkYz;VmO}Os=XTIWBq$N$lG)2vw1V9A}R(-PrX}7 zUbX(Vq}XL@szr6cg7+lH%Nsh}-PEd2BMSh#lEzS`WZSKa=9|0Gg?^KpqrAb5-4wgY zh?6_r=MMVGk^YzypQ`*>iPDgQKGTC4FFk?NU{aO^jk(B*1U27Jo#eCU9RFa-80!b@&GD~H8hH+2m zZjADk#}Gm!-JaJDqAtM-b9aooUBp^b-TzS1xy^vT#%P9`5Lllo@A zuu-EvKBYW%r*#hc5zHHRH({3H&67r%_9P}*CC_ItJ3c(tj)nOySas|tX1WJc!q>Qu z<&4zd%2C${H_ve%!S%BBf5oATr2ESo*sB1iO(~r(R~ucHPqFsV=+G=Yc0Xggb)Cfn zorA>v^R~q-$5-0CqF`vqe#4{49c-n059aK3v=uzkKxhKXNanM zy*Fl7p~0d2-p}b>W4hbP`Ijzz+6K?1+`^cOfhhBe6E^`n_2j0xv&QbdG=T-X9D9*f z?^Bl<+jsP7r8W$&KA9U!sOMAb${3cA4SA@v#qNlLR?n=;6ZmUtvQVe&@sz(WD9}w! z-K=;)@X7WDQdeL{{Vp)C@+#^Sp@a4@NwI7IYN&D^V}}qE#Umt){RauL0?`l$Sn)I! zjY5LWQ_Evx$7eot78VxT^>3^Ws?FctXny`2sm9Nr%anb#+y%8*T1?(sVCToQQGyyf zU>2ftr4Ml7eZcj`Bf`|_aF8_$8k73DsgKSuxZ(6sUZ4*Gf4WyWP~v^Qre0nFKSt2L z%8fRLrmevU}G{?>$TzACF)5d5^;MbmjsI&r`zq&vT` z5(gEpFDzbIVD+hFkOoTASIt;^bDT_k9%aj&-(#wAB^Ri!&NYUd@QnJ-yH1grNM{aK zW%L!zGT{wLt4nLWHBdeQDZ!>%W}W&(Xod`D)0dLyD2DuVp71gx1?W*be|Asynls$N z@T%;o7oQ`UG(M~b+GLav*tc{Fl8eVYjJl^yUv2{)do9~>0!Ttz2{&FSMe_q=H?NTaFXvx=P9GG}=N+&;}9otMpN`}8WdhqGJ1-UY^ zT-qM^p!<}ZU@}(WPIuC;bPm}s1%GCp(J+ZkD&R`rOg+1na>_KRaIkNO@G^&eyXy6lvSV4Pg3WAcfbQ^6Q z)D;Z_;;Oa=-9fPK*WDyfx9k@ypha1!i=X#kum`^*dFqNVwrQU_=aJT{mlp#3{Dda! zePueon*urwUjTTEPmL;>%1<>9yy-akq9K$qqVcTi7%kZu!i*507vOd!AXjq7w<|@e)c~m&i_m5xql~*M##SY$=hQ_Ow??% z>g^^6-Q4&-CF`>kpQFECUA<7ZHxN3SCnC~xfBLM$=Yl`FKxFRO>(j$HiH*dMVqz1{ z4pqT@*D2OY9+^Q(N2A99yZO)n{eE3XGDp1GKa~5iWz22|lQ|AKUWT~`OJ?7T`JmFO z*uRrv`#vlK25_7l@|cQFOgQQnLbm;ECd`DiaMbl{>C3=J1OCSn`KIe`S$Z_ex)rGq z0FIQF;Z_{YCGbMVVBdYb|L@qxC9C-{4>ig>W;CqNg11U-F94Rtn+6mfh7>kp)s;Ji z*G+xyar*0L%`F!z8TMaxzJaPUMx?%buHuiuWiE=$ZFtR7kOkyd+uCmb)5Bjy2F3dj z7^40ehwv11aw4{99hez^_lD9-e-L*>(O5S#DoK8&i{|GQQ zjA-wyM%a-w%{ELvdwYLwo^!-a`8~(>W6F=)v8&_3`pB?pG!+-^wAH8V?2$HZ-#)KL zb~5{3kK%CUOC9p}YKPc}ej+ctDq1~x>ax0cY`b1=Q95T6%MB(us1zC`?emo$j}&*} zE!X0f)L^03@O?#<9K4cb-&M|FkBQ)M6b{nLdKp-DJojY!72S7r1@L@Y~NYt3p^xw(a@iHTW~&}aOXP8sTiCm)-%Ou825AeUW-$vzX~s3{9(YmN1leQ>Dm;{W~XR!VyFHtdG{h@ z2!=wH;885~SV7|auY#;>3Vee&aRMD>lWFQ`+uPgM^Fi64_T9OQf_8w;#nLzD3~6?- zL417t+5+jXRc;R6R@Gt)ci*VGjmyx$AjuCF!7puY+QkK-&#exznsKs2dl^8BK&P(< z9~%1xEGy@ZCa0#@)n}cX+Pi-H5xpG3Oa+P`H!6BUT@ z<^`J!tPyeH3!#&pr@0$0G;K=R%ko;*rdL=Qa+6-E7;a@R)VdNV`<5Njj&&*~eN;wc z4QY?i%&U$CBb8ovt<}873@EgiCjcBW-Tv5cH}n$ZB$^$>yZz~88zXqdcj}{X_4i-h zn&Z7LWPJ3WCh#mrqV&+=AWL(z)G?t&?UfMq3bE44Mfm#hjS*Ici;xzZRWm=J3C4X! zP7;fwYhv#-Xt(ccOSllvRS~f#IJQ%{G!}ykFBIk(A2aTs^IpOe9#gkS&6ZYh8Pu9k zpv3(Fj&e71rm2cWz?9Y5yv&6wMAXy8xwG{#DGBB?;cSz=WhuH*L4!`4-R~9^-=h#r zc8=*C{)eHJ|NH61(qX+hY1pt|RtVlKC4{6&*;Mc(>;j=JVX#p3m+eX_v%uAhCt+b5 zA)BNT9(h-`Xy5)4%&U1wE|Z{Bhf-Z*GolLYp+^@}b~{&;?NZL7loF1_`iG*gWH}pw zg#eW;CdiNqqmEN?e{RBCJQp_X;anA0Fd_*tXltU=47d6KuzshKfvUwssY>lpz@u4p zO!ytO3g1XcM$*+V2%^8Mzoxq5}r?ORGGGtdO869o57$4bbm7zyKq(IWZfq3g^X41_KdFVmLcK3&*t;I9Z1YjJvvh}}cK*e`0| zpFd$E8j~DoL$wALWGS=M{%%{E5*j-p=j5^=dt_S{Ak?^L1f>jNhNW2 zl{UsLP%WOW(c9$PS<+*ZIRdSQj8W#^w49z>}Hz~@*c+h|#e8I7*H{tZFA%DJLD>|N>q8`p- zSHu$n^t)?wIj2y`s2;(^fJ2vW8> zu$FWosl#DuxA?MZ%4%!uT{8-MKxYCcqf2YhRrlbZZ|Au^A;W0RxYJ|HC!*U5{;MMA zOe0hnQp}0u+adLaE4uEwD8(#_@|ICSb~F_3fV2TSz9Ql7Hu>x@JKWMi%x~v4|H&UC=R6BV%k_5cC!GA)3C)J-2BQro+uL z`8%W`#O1hA0EKp59Ua*cV*OuBD6?deq_8}!%!0Nm2Mpt>D|aLSzdytcB9~*P8F)zP z>4*2&C_$D9gWAQ*d<$%!G!ZOD{q7NxxWo-&)egGV8Bme@L^{qko?|obJ{eohm+u9^ zLvT&tK;+K9E?Enm<=ZFxN7O?R?He0H)`rhw;_A{g`~;X(9{{kY2m)Q(F! z_!+P(!Zdq_flqG^DVO7NUp&%+Pyf+^k>;i^NeJv;W5gUgn|-vIG?_ot)5^45SHK{E zKjd*Ya<6UF{`{75gopowvn#kOmw0}Keom+UCSPh|Q-|wj;OEYdS3@ECrM!vD`Facf z&i27Rt%WpRrJ1Kk)xl&6u!6CGc6h~T(f~HmhPQ~v$`OxN zLEMUrQVFr&fK1Gjru>@=D`Hja9}_mj{Vf)L^Cv#mhA8K~W3H8y@`T;x!>=a!#r0_; zTc~4jmhoa9wH+yyrr^bX1d1IDm)UZ`w=h7PEv1p#LCOZ%d2lkDSgS|~LfD`NkOug@ zXXU*l8nXzEbi94$;I$`e-0OjO+5p$FgH%^Pb;8Fd4O>1sa-vr4nuL8)>hH20!3A(} zQSVt+j^v^6Y_MW4sXAjmrAVh&JkP-^R23_hN#Uo0?MD zc0%+kV%ll65EUU1Zbw<_yGW8k*Yv!f`aG}!wijgK13&Qh39vZaJ6~nI!t@=|LnXT~ zxItC0mU%clo3)?a>utNa zGdD%)-%wc={(2*d^hoL=Wx;SU>Ro#>I4a4O5imd$%f5oA`awyDRXeu;Q#79Fex{`nsg0a>XAAWzUejSUqe1rJH zjmbI(x_7;sxFWRIMbqD)qzyy>Z0Flj)nFAH$q zdM=zAV0_v|-Wl-!?o6V+WyHwi`Mbyna)oo!SqXUZS;}3UAg6qJ|9vI z?U;QdlK+erp_t+Eh2ydS%=+$bIacfmXmQ*;4SR9+JXT2yU}@QLyx=7}U2^tAKaiZl zZVK`AU)2~PH0>@$f{Qlg{!$<&5)J8lPJ$gG}UU z*GbjhXJ16zw$ay&9cOFoR>s2(VY-Km2Ab1KD(d9acGQ@>)_{)sL~`O{@`ooy;yPys zwckI}eKqoe9Mvlla%qUhF=4Zq$*1ia5z1rWPQY-D#T}J%o}P?-G48J z>JHGqf=gf(yfA-Lqg)HWyNx7ucS3 zB$JDv;Imhmwy9xV#%ef4D7+gfWI%VaMF7s{KGWskb7B`!QR{ozmqDAmD3j)|hAP-{ zf;*zV%ZHu$6u-m97=+}sxI|P~)_M>WKC>)P=~}9@Oc^b!))+P;SKi1_I9VZ2kx7c0 zDsb0ddGa@Vesn`k6vnLL1f?i!=Z}L+$PfcK@g}x0z8VOcW4#-m%bC4?9)vMkpWUPSyOAl^Pd=Jmq!R`JhQ<7AF-4JgzKnKp7;T!o@Dyh&s<#UiO>4*#$vvZpv5mRp}tmD z6_Z!VD3hpxKN$4MKZVGPc0ue9M4?TkXtLwoOYWSqDiJh2Q<{0eSM&#hN?$v$Y0vG} zfO!3~f-jWHb?2kwx8Au$VQpHUu=(O3_jT+7Ce|avZS)5z@$AcB;$AsF{d3xRNV!4g zi+;}-u5*N{DqX9dj)O+hbrss;tkoN>=F8zATRmy>gkeGdudz%>9YX!8)*RANkY=x7 z-OUJGTuCh;aIw-9BV;&FAww5-kA)MShPsBo_P6&#?+bvB?LF}>OMPcB0PWbQZ0 z7vhT;yULOJYf;J=@a|njFA2653L1w=H|b}jJL90!{7yEf2dOHF7Bb-bckmU@yNh1k z*G+3Va(IfvKrhhXd51Kos>ytB=+3{P^r5cZ33R&Fy!pEOH$|@Jqq3W~eZs-qU;ACd zckfZE*2IbK`Tr_pY@EdZ+H=@V4VeeN3Pq04qG+`?pO zn*&Z!x1g}$wmIp&NAVUb^O3G4qT2xaGT9OJ~6ixheAp=??Y10L` zu#~!b#p-AQkwbs~tWZpmCPvE&P+He{3lMvtalDF^Zq_S56R|Fg*PvmoEH2q7-)K-)iV&gP;1T$K{L@|2aLKy(eP+F$ZkXQ&e?l6;Z9-bjvh za*_rev5=K8oz}$ zH~QOc8gu9MTGYN-2nj}B(@o~{Oyl8qEecCsV6X|aFXwB3nPzsCC)dNtLX#cBSQ_eN zZtBQ*i;1OH`j9J#K5Ep{kIEf9lL-K5hWx-Ic#_w)MfSvZnI(ZZF?vfkzna@#pY~mr z{pQ=bpN|?C<$tk%jaU5m>Nd`YAPC6NZT*?r(3Lthdw5Kzc+Iw;QBO$-3e@Eg0I9ZK zM`zU*5qLXHm^jPdzsz+Zyp5uIzehY9SoK^A!qM~nlY`W^`yYT$N8f&mom}#c=u|nx zDw`?kArvVo>lwMupy-B!VP$Y}(137#)f;n)J7aL09)$xN;|rjJ+oEwHor{OO>=s2r zK({Sm;xBDQdG$MIg{L^|eV-K!gY->YSj{cTSIB>9%h_~hDdJ$Vs`_I0T@ab|qfCzHvG~LAOFJJ+5hIO|4E%?Z8!Il40O) z-8VbVNx?~R<>BvWQ;y<|&UDyyp!TPcOo<8i&3m-(s4nD#y0#B;RT0z-Y6K4k#FONb zu6!PKiGm=5g&{VFSS6v0MpF=2o0c=~<#5R$%`rh??Nj+|4=hTG$T~0Zf*q!0>U#q< z^1kz6xu?^af+|RZN@oKO6$j$eDg;Rh~|GBP-Z$!i_<&F&A)5-(L1+t z535u6d8O5PA${$J<{HO(vFxd9Lhmcv<)^9Y>f8XtgT?C}67_UkT2W!}u;% z`=LX~={ay>U?4!I9W8rD!2Jc8(x!2@?$GNCpM4yHU-zAur!iiTv?|fiBNkV_vILV` zXQpR~>e&gZCSa2#k-086-V?8Sx? z<>f)esi-nRl4@sO9IH1*Sv@;8{6|wwQcP^9b*7{enr;)E*-UjKp>n_NeIQMs({{t* z_%n~Iy>H*U@Asu{*!9bUytIpKJF|gXBJS@6gfWz|rkA5AqIdywy(ZE$ag}o_C!)zY z-Wnr@veZFY89!;U9Dt==UBP<<*8a;&;wv;z=X9cwNqma9sX9i<5HlhJoi2>0Uzs)p z3EL$tLJw)1Oz0o4)%m|`C4QNC9jJCwPpqFyUh@+#ElfJAY3Hiw4XmZ( z8PcOq3uN9TwO*8}HFo7LGx9x|%P6Kb$G*ytv>2Bc(<)>XXN{;gU|g8!d{C=x1)sz( zMkL)Oxb9v=c{T2X5CiWouI!_4Oo!YUV;7dwu|0aA;PF>rAq29eRXV3WNB-P_uS`|9 z2nIhfiIkQT$W&{e`73#L=Jqf)1=;hH&CqN=BPv7DwRZ-mv3qC>YR7(7-7Vn43cY4k zeRbh2onzSP`><@lSonG^_GSaRy?=;k3&OY+Pk^lJNXWLvr^iZ#$ z20`gCYIMzp^!f<}PkkL%5E>|}y7~H-d(-@aFM(4qe-+c3id1~DhuM8}lMhY=y@_I- zd^d^S{W8s;Gp(3y&dsu4J;Z`Cg<_RotuYeF{sL`ZBIPazT^2R#ZW_on0wgzF1zfKu zrbUSkZ;vUU#<}T^)tSCN^BG>U4KJJ)|%-#F$L!q!TzzIVVBI3(O66(jTx!-9?*! zDWMW7UpjI^Pz=c~;ocC?jJuo{ITF)I#TR5(DNgbY@0~l3s#vub z>@vM^9GZBZ&agziDPQ_fxVKOopm*TsB&P1W2K}kTr=%Gzyo3-`z&s!@q7o%o^c1K$ zLR}K>5#BmW>rqG`@W#sA2)VR8tZA|^HI;sII6W~j5l=6ToE)IG@u1@^cHh8~#-c^b z`q_8(-(2YaQ@8CDhK6s=0SJu_hNUTPG!p5+5orM zayVYWO}hmI(stIos+|qgC09;ngQVpvJ&8Ti&$P>E@|IzE|C#+mN9fNGJ(DG|(mYuM zgQhu^1u-ur;d7idC30o`b%tW|;wfp52epcv<4gyqA~4B#B#_L*&?sDlBiY);Kr(|( zc-ErbAPZE{PeL)SR_d_`inOsa59Y>rXpV@xpwXP;!mhwrcDi|s$a>3hQ?!5D^14_W z8LQ7<{SVAw2{K;jhfDts?eh$B=O3@HK5l=FP}>_Tkdmx_6*;$P05%V0lZ)9k2;$Bl zomJG~iL}Jxh)n-vZNly9 zjr_EWbiFJ-W?&w%4qJ}*FXG)$#e!uC1))%=U#5rYj`Ns5gOQA+4I;+fzQr5l0OgjiQ2eqnejEHaLLdt1ld>Sl@xSq%@ zszo0%9akMNfZadh=&YRPC1))AB#qMcECrF1n$qzM&)U1YWf>CYMCl2zJ`m9#|Ga1X zeW+?$wTMY&hT;(b#$_(xYOj&Nv(~hD&#j(po%~#Tk1UieKFX^d&Wk;XaD2sA?9yT~ zcB#SNHn_^~*jG8b=XXD)B|U0Mn5di0p__@2M2VU40&9MoS^0$&m`3ZiZ!%75eg^g< zM~^;wtsoqAWW*wbSTGtvzkdH|9T~4z>e#b?@^;{CyLu`pk@m5%@J~##1$Eau9)90* z#d<4eEN34ggnFEAaaqrjMxzI7^3X8%}12R)Nb&zCYP-D%3YF%y7MicZy z0}YF}=@L9|BBTBM+CMhfo~*bQz*H=1F-zXenq4&(;A-b5lU-SLT~RX<2gi z5i>64hAQ;W1H>|77qJKWEc0NXIRhMzCupEY?6~j`JE8<;Gg`mtG3eF)gWbE<#)wxS zn1PlWfJGJV!NNVuwcXCsCCFtp2_Mr`AtRm)yA|VzC7d7#BJQFaKYec;4Y&@uhL~mKP-q5JbX0tdXWvRYj5}eb9YcvUCl2b@M^WWDulbt1XSMCoj{LH?6SgV9&JiU zYM3bINx>=;#nKOqgc)Y4OFvsWc{AH|ZKrCf!3rYnLA7eLtTHq)@B;Io%29!wR1J7F z##u0bIx@2`n>fjch|C?m8Mc|0#Pk5;-KC3ZlN4&1&pQKY2tPb8Ht1L-(Q~778o@_W z*8lX)?qfx9HcSOCqC_)Ib}$w~gaEfz6WB{@r1m&AX&NNKyVb%fWTlcq@y>-%^LW@U zkI0}MQArdF2T&ih7vb%v$U4Fu%f9lu53>RJAm!K%svr zR2$)rihh?EI!!prg8vpL%){d27;+jz$oMZ0W^T8lV^ugY7@TVN<>F@r(zkC}vZb>V z`5~d6H;y_?Vasiv2S0u^F8Yho?D@ruU60z5Dw7bLnhI1$mk_SFaJ~Iig5^p3m*g)6 zziMQCNo9p0FFg?!mY0UxGR580PjVD*vRR)`Jr04?O5-+RBhsvR5Wm1$6QzvL(kkP&vfuu}&6XE1zyp>134}l&7|;l)!i|u6&}FGGi$?{&XdZ)8XaWf? z>-2MXO7frYhEWP%*7C-43xUX($t##ZhQ%{u#IM?*ef2HkgTe~TQF&r}Nh~Ws!lb$c zU|e69G1e+Vc6xY4&JIHlJ)OHVldL#yZvHO_gv*9Q0eR}xw-sB`aJRG?P5#jMLBoJ7~H}2LV4ImKAk;i3yi)GaG zcC23B7#Eh>c}=^fuxYcMNbUrDu8!dqc*3=-eUjq-{vy!n2&8W>j$q)D%$G}mg2N~*dqqWWkVB}U*?9k)drmz z+1PUAtD-FUea=Tm4OK5iX+e39&w67q&^U_LtGW%tx3P?ol55qYQzn_%d3#Xr-Eo#J z9dLVz98Yg(Y%GEy1#aEQhZtP|h*L=!9W;qCw9^AI4+!S^jPU#-Tw9RZt znN4;2OtvJmZ}Nz@bPUTfnPsej#zWE^$LvL+hsjNNSiYrP5g^qMO&#iwQc z{k!>Z${YDB>J8f@q88_MnSG_9sd)W=y%N0Hv}f@q5-8G@dyCRu?%znW{RF!`O4Gab z|4q3BJniLO`YUjXdS7L^wn>qFzkm{Xn3E?+pbv%{su-#0a`{OY^Wy0Xt(h>WryKsf z>98cjBKwOs|Dp4s)<}LR^8LV8?5*#D;vpWo%HprTOd^tP6z}TaqkLDn9FE_@AW`X^ zS6y9Z2YR0_fBW{W``tZ%=ViZP1%>j=!$UyL(j$DWvl)&qNYBj7{PYQV0&go8kZHZk z;>lUutB$kg@Ni5WaxGHpb5oShW$r}6WT#I=A*jDNw4JKf5AWJP0i=Bc5*WGlwQ7+QK?SgY97VfiT@xHj7JDoN96{7-X@%`M2(^>|lb zzWfkiS?FV>K$~{Qj^o;$FI6Tl$zu)D2PM1B9$?0Xl)zE75D}k5-J`Ly@GQaNtRD8~n zum>1VMM;VDh4}SL%7zd1H)CsYV9%7~rla)Q@a30M)OkmoLGIY^p=?P_l#^LTm||Pp zI`^Jyd zs#!q0Iy;ec@r1FiL1-V-q~7sEp+io1I7v?rij#%f|4UrcwL;mU@=7Ovzi;|7Zb%Cp z_Jv3o9Ch)gC5${>;)%DO^e4B0|n1#EI6+{As3H*4w6_J@G z)OvL~}kg@MTQMQp^-E`Xl-$hc;?P; z%a)Up-YBTEMESaiD_D`;90EQ#-z)@0IFejK6LwgSDcN?leS0ZFXUgw zSrbWTxD{f&bsHE9A|P8gLDE!J1Q~t(g2{q{WE-5${|^@s>dZ)lBTM;z44Wj~_pFte@W< zeA+zou4}8SuYY~kw8T@~{Ax3B!|x#fZQW!2!zdTnxpcDa{5qMf%J5_)i4_UdRTCI; zK7D#I_oG`@w{~@_)Z6mY%EgO;7dt@AQU`Yi!$rJ(`L1%faj`SC5Q942xt*o_zCM0m zYhI=?e#}xW=P95yS+})EQE8HRtjO|eIxR2?BH15ZU~FL?9DYCj6A+a-?oeM3LY#(M13|3~&%j@NyeY`$9V52k#`$NEi6c+y0UHwqVzeeR1VW?$pT z&6cVcvj2>r&3$?x7>2^J&zdo)+h0kwoUc6?RX^sutfIENOrlRUWGj5syt1yX;hu;a zg0X9RfT~ZVCelkMFT@|~713${LZr(nE_bq1Iv?Z(!1KNlZi^Qy>$0i$OClq2%ZC5S z&dv@p=Qt<)g3z0j54i)2VDZDdrfzL^uC9c`875Vf%(m~|{q7A$pPQRQX7#qa{j834 zejZHo_rI@^YrbE#tTyP+0b!e!cv}(jsdBrt8CWPD{;o;7JB+~BAQhlu_M8u6lxNgr%gcpnL*QA6LcafVGVEkB#$@XkXe`^dHn3bAP}?R?2{FwlO&e_v z(%LweD&)X8@_djkq9s{w?a10}Ha>03vg2T6w3)LNdt7BpjBF3#5$ z?8gL(=-_{}43XO9D~pnfs2B@uS(Ze-$BHG{*r6O(ST?zDEn40mTX8jJP82cgk%MY z_Il{Zup0!)C%xd{>NL`?seR%Ubd#y3bF#AQ5Yl;i&q%(Yl={#JR-=Rv5+r@2E>mUP|XKGx(90*s)ThUm38 z1mVt(B*s_;;@t&jXR!)^5$eRRZzcuPlM_F?h1)TLz=R9??VZG%*m znnl)g=`b{sFs~!g+Wh>yJ5ULID<1odXc`6eE&fCw0`q)-$BcL%#WAq+%f~I-*O)N7 zC?w+|i8^4EsBI~WPIZ%o+#3YvGD`SlS+eh~f(Qw=p~<$w%AjhbO2?!X!Qxz!M1x|1 zt5}%h?4iFOmUo;Xj(s-R(ljB$s0}I@NM<}JpYci}W;mQCVc5NQgBL|L${qiUN!Fu0*3;9IxC4LsXV@18 z#@|a`XH@9&8`z8GtkaxBb?lwZgoQgD_L#C5AF6PBHVI0NxWUqnTACbWV|fj_3r@&$ z6C=~@yW2?`C;^a|Pw`ER8>;XX;fJU@Q!~$Api1MN6Gs@^=V;7o3+dk3*4MARyhxCY zDFAY)++in*^mQ@tU4f;rj+m{#Ne8J1kXz3lGrV>iI_q!paLWC({2%uIvaPE2`vQhVloDxaK@IlZu}Few>0b9T|e1xV7R+}a?^dgD*9KV=ML^9PgE*|3Lr``@5tSP;g|IqSVPZ@`+5&_A|y$dNBO@Ha!YD_K1 z)HL%0Dw&Op8FEL(e};!e+|(q@@0QZ{v-*0up0l@+?D`rZEUU)E{|j1;ABu@b&vQKA zgvMLya2+Ct(d$N)PdR&8(&Pm0Fgt4zueDdDzom)T$x~OOI$EMDsEqy8uZHKe)&7c7 zLFYd8c~_6r!zpW*8oq$m3t7z_XXAZTeiZDnZG`UZTZV;>MRdqm`n!Fbp$%JhA8sLu0?e2f-H2MSR#}wUx-%pjsCfcx8zF_jmr*tG@5^3 zNYSq9WnCvvVPAjuh~hoLh&tZ(HIBW^YJQH7;;+}f_wNr+NYKAqT&&DeU=O2Me3Zq- z_Nfim>|w<59~M-^G=t<&j)AD_l~;jCkW%{R#Ei!cU!tWnD`DhXrDfERzT~9NY0Pln zNmITg#LOyGD2}JAE{~|trZeO$(dNk2u%54~6T^o&h@ zZd@$J!sn`1_F2>ChJDx7zunzRtY$X4tO6`w@*>r<2dr%}tEuva6fPy5`&?3*&PuG)2?liarFBvQm8qgy5j)j(A_{jj z-hG}+jE&e0w8)w_*JP4*cdwKBVE7^RkMLA#o>dAtlNfvKrwVgf-J(KL820q(fxMQ= zURi;y(4NRg8dGlb&joC#_G@}}P+7MNu4c)(A%iL>!YCp>>JP(TMC zKkoB?q6mZh@P7_he6A&up%By3cKWuu$*lBXKLrNDcIUq)lawRt+b&I_B+g`2z$u`y$ltr%h!z19D@?ZcyI8!h(j z<}Xu(CPVMt{r)tEyN}EYl^qe^m`AyGF?t z);R~1(5tNMW8A$(?{<#Y1HenKxs3MZ;)NJ`Jw@g4?WOOThkUP-NY zS;9Z^c|LS94A_PWed7pw>Ym8X*)M2XqN8sVKi;PMFjC;iU6d)ZbNhW9W!diCS*_r( zmj)|MI)h=fT@iDmf7GNLd$VdTD}=l`AbDx?d(ecBuY%&dmK4zx;d^!A6Ve=qgk9pU z@um?`5D{hniD=)%8FXMOw5b_7v@fXm_>@1sNI7RFdpIxg@%c{?(%-k@)SEe|)`av8^PdS)r$pr` zM#{mww0qu911w(DPNyqa$hh;xwe~8d+ux<_!KM%Lg_0+|w)?Y~V%op5 zYPpJWok`ozXX6t>2GydUEQV$L)SEL48!f03E38;x^!l?wVxf)pj=6GgU^@A=E1;Zd zpMP>v3`B-bhgeb#>OjBm!uuoW= z+6gr(-G!QouQx32kjusm*IbWimvOG0h#PEj=r`Uhux`^D!VgemnSJ`LMrlj!eNj}f zR=%L}cD7lO2Ym;HC)G8)ix`SYY=qq@zUSC~+V?vey>}@;BRe1aznwoXYQE-UHZ~&m z9mgx~gF5|>&v7o#6jC(}KDWyJskL=3;=Vfp$5ecPmPKZ(!ZZR+Ym7ISK*U@f1bQdh=iN@MO$h`D|+^T3YVvf zL4;g3bHs8*4ng!v6BdhMDxQM$d-C}nYD;=I$!6rwW~R}<%xvH^679HGg14;HPJUby zpe4D;QS0wu&DarGqPHrFr>W)OQ8wK^txx^eXzhx-c9s3I2NC3flZ*e@YW-BU>#gJW z=z6>|&lN=86zaT5Rz^Q-ux1eNTBcPbBBZaWIVG?ZRsJo@5fAh8dk6!`4cS8BRn5^C z%{z?0{W+}ehG=9(q|D2HjpgYVgg$+>*v|@MB3vdUn9pZ?hpwHX!~wI3{U>o?rs8)i zdwMPzua%c&YMp7~f!00_bH);C5=yraTMEr;H3g?{sAGAH;1g%#GJnq{F_ZBq{R>O6#8N$hM{I8%50q<}SB|Cb zb@+z{;FH=V>yDIo4x5OseTx}QQZQ7J)y=YgLJ_G!*C7!-4TEmtRBKX~^#%%rlwSyP z?u!=D3aC7Y`TX^k;&S(C$^}oH{*`jm%H-1AA!o)=f`Y~AXKEAyP3JSSg$;^t$Z9QrPv}&;+ekzl$UlGKnRT1hk3RKz^czyiR2j^FFBE;GW zGdthxNl`}JT_wOz=j!}S28ZyJ;92H7YJnRcJ7wf|a6@Q7)vw>nffa)s(QkeXy$ zS{|QOY`d?8Y~zSMGN<;aSQ+Bu%L3^i3VlSBMr+3TbTE`(g=^`e`?3;2lQ+}M zO-0F{yj4*#GLcSy>i;SYGs}`=sNK9o#A)9tv&H1)#obZw@1?9RYelx|p(`QHdGr*8 zmo>jk+;wviPZf*|m1ecE^>tYv32iI=s;D`Pr_QsnSlTGw<0&yEdA~+_%>sEmmC^q= zo!g3(2Y%0e7#Ymij_7+Ap-n#`lQqcTO@PD~vSRy!f`F^%IfexkM%yOESqA0NuFvi!@?)NJU!`CNyLBMj6Ky?WcRZ&n(fQASrg zta1h%V|AN@{xhk4eDUJc9p7E5&Mlv3Y2s#~E|?^hIU}#W@nP;+r38DQ$&jpORmM#J zIP)tVCF!W^op1DP61CU=*nt&+Lf=x({42MzxZ{vYDYw8ov1f!iDFJ=@$wc(?lFEf4 zg)9=ib#nQ==i%q51%x-cyv0Qj)x%cxUrl{3Z=zR?rTxoci>UHIY>8MF z7w3j7qyX@075d-zF7rn{un31BEm!|Zt#!L9>Kt+>yPS!}qw~&qU^}ZHzrn8tr=EXu zy-EJR(z$s4g+;J1DY=3IWIgS^0+VY}e(RcrHfAP*7kTg!&shghWTvVs68+aK*lw;_ zJ1_u~qMR-rJ--wB{M8*Lb{Ux)*Wa13d{7_!y|(wY-ZM7uRFNOI|C8-3wRp#Wt9D(5qT?qW-67$xRM(_$W%O^4bDfAA2nh4( zWE5F)JW@DsXMEVM`m&NZs@3_|Tum#F`+g^3Yj~-SlX~TqFOW+m9ieJT=1v7UP zxb802IdM%DfGdFgMcnbAKlJmtj82B}0I%>({Lq8spR71hLS5i5vT&>#-(7gqLrs|t z?p;`pkWj5aSdsI;iu<`wbaeLVE|8>)j)>e-drYt+M%gY}upz=kV04E$<9R!Q(&>2a z8$ux$3{VTHcW{!F+;S;X!e7BWpyzL!h2bU9)GO zh_!Qr+Cl5Xi>kbtGCIZf`78c@1Gp&`g|}1cNB#F1KIsi=B}C|Rax4n+Uenz<8JK2f zznQX_m)CfTBb+DD?4e2jfWw@RhDwcKqvS3NEAb^i`v4l2{l_F9X97p%i>KeS4*e(5 zcQtc5@*d+{-NdSeZkQ#`2^)(fFvj}vKM_?~pN4o`)kighL%97`epkP>&AnC1x8sT5 z0-f49znr7nRBEJ4i2gxb8J{cCb^b2TQ_7&F6tT`}A`ardMr@PL<-l*(!|ug*$mf4l zei#zuFqChpPDG9pdT7&<$X3j`N-JLA7kS=^ge`%<^aJ=Wn_uM6MQn@@*J5GAjI3Q4 zc9#|Ce45pG#1cjj^y%8-wBV;lTs-0$iVrCs-)H<4_v@|G%5D1C>!bQ*eml`rqhgnP z9qHGy3$v8&c$`2yeJ$&_clkmphaV&4eO`pG9QGD`*zGCQ$o<<%) z6fJv<0?ys{vXZ!jHDcd_*!r4!>eGd$$@~6Jn;Cb?{ zUXy%-n$qzI^1De8DQ2+zL)J+2slnpDv}pB>)#{>pe|stp|G@S0FYDe^pQkLn`SBI= zj~cu-)~b((6blsP_f1uk^m;#-t8gZ33(-WQg+qdNP&kF`GE^=Rj&p+B0t(#G>g^Gi z47Hvze2*eftLY~pj{X!rJsgrq^;>VfmfDeu&g^Z=Cnv$KQqgyumf)@%z!6e6PknB} zfBBZmCk_tUKnv4N> zaQHRHgTRF6rgq3jlPLnr#|2?rf!pWXjXtiB5`7$}6##JnLmg*bhi1Dubj+9jnv0*n zBo(jHfT-!q4Ie%80qtjrq}!^l?839Z2Vf|8B3g<5K2}K5Phg!T#j5nXdfnkt>GUQgmwBjI|md0iv6*HTo%Dhw` z^$qn$PH&3Cy#K_S!Humq*6`(qY{~(>O7*KOlXM*A9x?+@&}xld61{E0q;G1#9ed@F zvxPwIWI~xdtG*bry(?p```Yr{2;Pe=Gk!i!=bh$_v>VzBB2j(MG5faLv?-j{D3K1- z(VasV{?|@qzN5S2!~`?a^|p-M!33%?w2wF$sy{F6O!2TIBx=K-|55V|Dk`Dxlil}~ z92YpHC)IVEMCKm#I@f-15k%FWh$M@AMj5L3AfKk}|Ev~~(@d>_!nd!CALZX=xR`@& z(U@`&nI|_ct8|e5+puwE{KTfJXgGj|B;X#BjW7SNHF0bI9Qm3z@q&o)=@>s3+I3l0 zu-;!o569T4gatm$w>$sq4iNBP5lg=DqsMQR?xuh5-rHKo%Q>#Zn0)KWDGvJ+PdaPg z2}%viB$}F&?ev2?$-LB~myoB=_CK30dRQUh5YNA!W+OEj@73D6}3E5K_*c=Vqq|t_u#~N9z9fYqyBx0sEvf`kjfoIEoOD_2&deMWiBV~8tDlzXH8oNpM z!U}U;3tcU$Hc1Kl&EAE|22UsEZ8(s5H@VC?`;e}Vl?^wxzsFwLuhC5yV%|$aVPA(d z3WfCe9vn&^6A@-s>^3vDq^b)2Kzi?iGP*(RwPzcbkz=peqQu@O()wxtOB+nDW`ci8 zjvsTTOQI74S*|TIJ|N3_s;QZb>%TBbXU3<~D$N`zm#Tul=|6PLlo5GCs#DXD@axAy z>+*&!PFg)14}be3PL#6rMDncyvJ8(M6a0Gwj=Y;scON!${nne3JR0}vKi_lG=q@1z zFKGA{acwb8i8n;&{^;wAY_+2Ak#-4u^?J~30{S_$ zbCz-6-K^WiY>{Hgq^Ac2Ck%$N_9BXEx828=or^cZnPF5id&xJNj_qHW^4PUL%o=%= zd+QuC7QImU;R>x;Qn{&svGMO6<*dA0UZTRor%BZz1FsGh4;H*W9x=5DttC!h7F(PZ z#e55Q<5wOvSg!NDNt>SD<76S=E>m3NbtsSe@l-@w`a$hSoT=+l@N&|_f+vkI7kiT$c>-LQ>P0e4cn36 zcIztLJe%C~o;sNfb~*HPdZfsyXtj%n-oNTgX&EJ#IoA<|I;be}9_j)1j~;=W{Gk6a@7dWD_U!EBFu|NNOJd;6*7_)?ZY9~R&C_F~r)?`x z1S>Ic(!G#yPoVnuULvmFrio0BXmL>EFY*G438(w?IfmPmm!ye5$7&mS%;!j-S*>|v z+wD*B@Gk4Ea(D5u)$Vk13+U%-D^QlFap{JJoBxCezZ8& zQuJuKEF!Te)>pk&+BFIHi8`6swDSo{u#8aP99tLuN;f?mx`>IVAd{IDZU1o2?4rbD zOL4Igye1vr-EKjQ?XD`f?=v+E5oWsr1xT@D>?kb`tEXX7Ie4&A!)q3`}o4 z;@qBuP)*l7?0Blk$zAUzo@#tHXngiNN2&q@`56cFSGRhuJ_sk#(D$?NIk}s*zrQch zC!hJA>=_nw)?3XHwlU*Pm<~q|`8ouB4DGELaxt_i-1K11{UhFZ(EI#O_2PWw0(J6p zI3eIaiVNS)19Taon6~WaGCu13_2O^JsfuK4?IJ zfpO^X@=_F75QS8Ic4BCZy&NeYUzL2lrxx}4so}6l`{%--N3U46k}{sls9Yy!)0CBbal=OGwi|0e z)5pBL^wS^dr>Be3yje;E&M@gN{ixeAkSs?j-}kELT`n#zRqquIdzjbjT6=awdgn%w z*F0AlcWv-$lVfJKdP7x}JGkLzYBkiT`g}3FzGuU}S9y->Sx;!#%QCEWoyp%^$uIKxdxQCpbwvh8*c>_?vz*S;fS$F8n;+7*_uh#~kH8w} z>w7NVojQWo@3Lz&BsoshARyRcuYB?OZY{?K{#1)$gKDOu@;g7?d<&PwvBS%(WK{`Z z(lmMehWTkkiAoNotePQ=+M+kh5O|Z`K>Os`f64^aV30~btXqsTum1LpE$cK>`ZzN$ zulQ7n;HX9Vv}M~pV*9XqG3{ieL&_E0+=JFa$qk})g7lFN^_%4d1qBb)ey_Va>Ui1N zZPcuO^~9b``5w(DNUy*OShq3u1dfLja(y$We}~jTN#%s=Sk&1_)H*o0;JE@%1oH=d z8gZHUq@}U{1xx&eL-ST$Yk|ePN)jx3UuDDcp;{oz-Hi+3F;xP5Oi|m>wAO+`qZ-zp zJp~t~{M~zc*pDqzznq9AZ<;W6s8N~L`8N@@E1ro?>!||7gGhb00`N%~Lo!|n(!<%Wm^tLL zPB^q&J|wGFQB@VWxLL{#jSoym-{tAeb|iSacG9s&>ERhKEZR3_TpgFl87@`ekA3>( zeZknky^+-8`varB3>woiXYf|yGNbS5#w*(&z!#0sWaS{r9X9J2*J8G(f9J|o6#JuQ4v8?XaGc5Exn6yZwL$d!SUAY)-dWH?=tzfew~FosmWdNH;D~%l~z3 zD$mP&8j}5ohLEUn zL;l^zW(uE!^jxhPplYFw@9JGw6Z_Ah>B2O1$vCq#;>Bm*vUF?#}3aEX3R8|G_BcvoJpKQUM76(ff zSp9_VAiGKw$$EBvQA5q2OhY3hIGHfY_jC@s!;5{jTl&-LqIF>fTF|GNGRL-z@nVNiUix^i&BTS_MZCDtf?xC zJ@!7kSj-gG6JoV`XG<_C3Z{fM4`>eWm!<6&$bBPVpXzl!6P=3MBy=%^1CwWL44kZW5ip!Shubsw6}f`e81!zU0M zlE4Xrm|baX*}yV!a7%73=jpi?)j!|`gEaOBg*`z5maiN;OPxAO1%QD1Hq@|cxcMw% z9^xz3j~VTUtR7{mcVm9;#4s9tS=INLreP}x46zsQjwTrUh*8(C)HIwOj1|>xh;y17 z4)=NVI>o9(D}&uuF`yHDN+ zHYUAQe*ybvB9ssM-VmtR#%I?nM) z$6oEGKr@iGq03T_)CDgIi2%CxqJ(KrvovZ>)2hz^jAu09O0? z(+~G&q*)#&Wup!~QHM#xb=ebkq<8^+UJC*V2CsfNh&uP~zpfvyTM)AM=+bA439X>! z>Ve`r`%ad#x%oUG`apgQE34cIJKvd0#@}~O;T?sLJ+rp97NqxvYhyC7X`f z%R!1YDp`I3fih?`782S|S(I2rilPOwznB)zsCP~qt)Y}-mG&J%+Yq0Ru%~_4@zs3? z=i3U=zh1CrwLT<}eaRQxngUPZ4C3QXxY6GAh!-N4h9N@lm3HyWrD$tH?~_%T|E7t9 zz&_x(9i(n~caxTDP9lQeLXaNHE(K2LS@jcgNs0MU3Z1|0H5WV`A)!-}YHRWNNe?JX z1BN_CVGpswxWPlCV5lInuiqasK5a9un~&FbD9*{tgAmZgQ@h5g>d~2Rw4b-X@6zi5 zG=uZfll;M?#6;*BE**L{9+Ak$6PsWjT6?p~lMi4FDea|6_i(Eu*wdJKH}7FLLY5~Q z`>~fV5a${n)(qG07ux^N_m4c<(`kI^DyxV(%zlwCz?<;Ca+|N!7N({+La|$+3E9gq zl7ODZKgwq>(_Gic=V<=%Qf(0`^KCTKi46HBI+|^Aq6fLz- zacHBC2O*E>6r3Fa@`1&^*{I0Bdpou)uN7tbJX;(shM^^bkrR~BUI&(Lu&&_zA&IgS4t2b8l&h zIN}v>KQ7!~TjS+LgO!?I^a{Q z;G-jthzvW_*@2)kvcgZ1Wm++8beAd0F~WBDRKdyVdH8)W-XZ>ZL6~11SX5PA4aaH> z4-dn+=mP^ThKnAP>#j)1v@|IA;X`Y6xNSh!T*te?!NI&dz)lXYeuxck9;)qgC=XML{;#mnB?h3_-eHjbiq<Tk_|=jP_NwaK1tnMHUnKQ{hf zw5eB4LHzLy(8`cBrbC ze$}uySCgT-lBna!RV7Qyk`0(RWbEJh3J&6IEP>_YZIT zVC@g|FFTLwzpT*Hsc9EWaji|w=H!Vi*Sozq4uQ?+WONuR2vRS|>XXaP(E4qme9+y~V@i3>k^mkaTsXjE+Cg+}|8;nHxEd8i8V$wZmQO?U zP62s&4jC|~jOQxq9gL>MUFuZ4S4+i-&?|+e>L0@Jg)YLrd z?mO*1J(c)oES^fT(TPO>(AX5lHRVgITq{yz0;HWeF)I7+m)xWfT?f(oUnK_xg0rn{ zq>~gQNervU=^V3f(?yyT&y8xR_t1Me(%xIsO%i>{{M8V3rPi%fPg>cfetqDXlWeX` zf<#j1HgdDEQkQ#NkkW0$2#yu4H&V5!Z)oVHT|GRRie9w1wq=YM!}ZUXkFx(PQxxSc1UmsWw?{2Cpa*irXY&b@p{9-=)g_L7}CY!~m$3Iv`K+$i@3-N4UoM(QwM{eHx9E+Zngt`=R$GZqKT5(B9Zy*qejZV%m z&^`~v-L}vqhw-OBvQ)B~ny{^>!)_BL&E!*(3b3aoEfhbc}kNgR5ou$V*apY*dox|XRG<>j&2%L4$3kkXLG zz~O${A}kMZ&I|+Mf|M*gPE8xt@kL|YuCk1qA*urbjTRl^YiVkV{HgCU2=J-cW8hr& zW{ZXAckYW2cjNN~$S{j6GPa*_*#CrWNbML#D9P{Oz6=#9d>YZ~LHEV7O(VseV@@-# zwju?UcKwPb{NN@akxS@ypkzIe<$e7NdS9c25?B?WNY@6en(l$HXiyQ*v>cXl+e1Bw z01oV&?`agoU04bk9HrbXwRPXV4T-{dS}E*NA0+$FR$+^#Wdj1jF572xPFIvz8s_`{ z+?&={bPvP-cA?1kY;|h;og3p_SK=-UPy=eab=bUCG}589ZglCDNkJm(4=B2kvw)^k z+TkncZTE}53S?YP7=Az#G?#90%yleo&viiGXxM+ZvPRd1iM$2Fy>;RkiScNgXCLAi zos+&)(ikOyv58U5uAB&Za1n zuz0H^a7i^MZG8SmX`4rB9AVHbxHk-}8bZ4{#+#U$ngYGT3_^(SN{$avOOf24GXTd2 zyr<2)CO5Bmvu>ml1>}qv0?@B)*e?V`2FY6IDKy6+7`F(sQuJ()+DwCyqXXX!*jv=z zW7J+%hvY^Ouh$I3*f-%jE{53kDa<<5B5U{((>OiKg2t65cGD@zsi|itD6D6M4gd9y zPhMW;rhg+750JPF`pd_36OC@Wufgi#^pPY?66i)?Uu@`u8O(m#6}*4fcF8Obr^V5% zyI?U2vlInmtO!{=57wI8oqc?m4(VW^53p&In1f17UDuQKN_n-tkNA>H7kS<9Lyjd0 z2G$HF*$l(eo7%_oVNP42elEOt|mxEh?mY>4rqmJ{l&-vNw!b`1m zOFJmf`DFFLa9GEi7T${z(t!`kTJD23fh;N&{QVQ}m*1xkQ&lVvHzuk`haZk)oWnVH zPT}GGrvb8bFKr;I3%xzpD>gpWNbbA$HeHDgy>Ns)EmF)h>B7Q7lC}s7%;q>k3KobP zTX2A!Ay76l1dIvCNIC<2{t^yykYKX+ndaka)Mm_nj=m@8c@X)Vn}mGkF7d`zAWH_E zh8fX$@!JK(TwovZo}+W$-YARh7gWX%xF16?jW0aZm%-6Yf$%L=@EkHY+UH8tt*xvG zaf4iIBj*>PTg?pL7oH>6xJR1VHh7bTChM!72Iu+H78yJB2tkwm?xzRAU#l1B1u?Bl z%$9}@CNwk;)C?JH65S<7h#EuniG`8~cWS-@wCgGz=MH-%twgxRBoxgpimELyfBKq_ ztjY0wT>x!QxnAL-uM8;F)2-G?dgY`>UyxvxTjClFVo5e*`98CrfU^)gMjw$aSHxt&ztDPj6j9vej zryu{$;epx>yK>jf*Yr-JiDgkqTN_5HEG6Lm>!fUil-fZ!5+uk1FHs^`hZj+{?col6 z@=`N|s_spfjNY)#Dp#CrfPhLEYJ-Ok>~Mb#enkOIB{hIHAnR;vk38pVkLWO~>$a5I zO+?D{p0w^D8Y8r&?}6pIE6f$WIv8A3e=rK+ow*)!ygCJ|6Vc&9=G?8ViFl`$j_r+{ zt_M2T8Zr_^t3SgkD~2|kw|_7ysw^)LJmVO5ZjL3SA^!P@yn`D;!~&DMu!D7o6V#hQ znetV#Z@B2t!N^GLud@tny=1dT9W>2f4Qq?Fp@|dDP&#@mQir4ApG_^0sKnetH0@*lpagqqDQ~_!yal1!S3H0Z>e+ z-PFz2(U~T2J2Okw0Z95?X4%KYsMXHZasB4O9|(X@^JXAa7ZQon_dc`NAJ%W$QqUUQ z1(2D1JAaEFvVL)E(BL!f*E12y0{6qypRcgUc(Bg~GNC#!AYtS=hG=>+W>cXf4%mWC9uc_q!@NoV7`*94MH?Hf+HKuHMA`O6E*_6^ANG?)tke**7K z3P?@4;9yn-fQV81CubmU0ydlU+UaZk+l z`}y+fv?p)2*WsAI%>TKYZsXu}psPcgZ=l~z*;N9v`Td*9`mbqn1Kph_f9e&A*T5&IprcTDrdb2@SQO2}aUuX|SDAsz^23^hq zfYl!wm3sq2AZ#U=%w{Nys2|)L=j@PfVkE?!m-{b}tp6n?wXEZGqaQ-qfo_2>wevp8 z0AeW2h_JFNC%57ZJFm)(DHAJRh=!UAnKS{aiL}qs17;+F!6X+FK}}mbDqb;0l4N0$ z-UMV-$lcc@j)Tz&2*)j`?C5@Vn2+93v*6jY_>qVQ&vg&dK#e-;^Od4TmCU@U^v@)B z?{8SxHQjCfg)qneAmbR&ys*K%5%vo3k3~UkCIxl@zr6bGf`M%Vs^^u*94b7a$vinb zeTWga-Ah?z?39dasb_!cq#NH@_k)^9vaEYW)rlt*P*|j(06^pLXFwV@g zIGG3ZTE`6150&mfb(S;(QsC=)CLYyHn!AgPQz0aHK43dioyKjlMxzb|7^*SzOQX*| zbfLkU(DS0-?I!4C(p&=okL-Vr&TS+{ne%$m$%R23Bdc}_3iTjjNr0;X2>>9=3Hall zhf*ZCCi?`^+@QqE-R|j7-DUYrm67z*byuRY!u3w#%c+K|nK!v9=H$6|3MHf?N_c^f zK$KRn(N>PNeV#`uk|*Z-$sOMH$sed@#P`7-0s&er`n#A2BT3ZNyKe;yKh${x?OV5! zm(SM?qx+CchWgl{E@Ds95!c8>#N!!Z z)}ar{pErPfBeS?9${LBWbALda>~qOFp5xiTx@&&kF^DL;sM9W#1dL1R>?G=K$n?kH zGHt!V?xQfnP<*MHGG`}7<-{_<5H+9|z2nVA)k{Gr12$F+P1M{*>SZN}rvtjYHfF&d zgLn8G#%Ca?0D-<8Gm_n3O6(z7Zjl0Q-j1M+M&h4hhZCTrBU^IvWx-_2smR+Xv^MQW zApOV1+O?ZHz>t72s7S$IY#9MH67N{Or`v9lt!t3+ex7zccowh;zDG1!Pf=4Ky`LZu z7zob=z{aLI15KQ~N;3|}1gKdb+oWt@w|G5%Jbt1F0=ftUbtI-HPwr(K6%BJ-HYpul zcm0Q=5$cG~L0)zg0pqIf&6Hd2^tcwzU)_I&8#x2i1->J_XjS~(98wBdB}svX(OeiR zCr-$a|rIgqb#5Jb8<*ZCI_{@~+@#xSuco@}S)@;?JGD7G*X{ zr5fNB4t^$CUos=ckAI^6Z1}4o`s1AX!yD`qFAYp`3E0IPiSoBIiT^iF3{ZunA9oiR zoYcA*q#KLfqV|`4P*F6XA%hg6gEG+5YgV4^QG2P8&?btzI_`c`F}LTzmmWdivZukR zHhUe_vteAN+%UruYEvk;j=@h+dZg80&h<&hq$T!a2|i|Mjb%Ki^_*?8BMwc)BKW9a zviw^Eowpq`Tr%Hb=-h6@VLjBk5hYC~Z@7AO6gQp4T?~;I zf{c_j2KomKI&sK5%ixfSd|W5v)f*v~i69TaWn4Ba6tEbrQ>LRI8oazm-Uo~-vc3RjRI!yf zE%qW&#{3T=?m^Vwgwh*rVhHF3n0^htLM_TAd!{pW#WRGC0uv0A;Lo1Y zH6&UmYdH705mC~1UnrLQX;;agwsCj@4D>{}@#(WzRypG_M4W*|C3_<}U^r^Z*rDm7 z?+&}~PCW1>m+jqg?dCy8$EI$2EyCO_pM8+TX2W^glUo|_-q%R$v*LY#QCEl*6}Uhy$z`mz%l-gM3q-TIFGqrTh4ZT8Wlm zQ^q3RmXwXr(NTG+9r8K}qut7#Qym+~Z4PH81Ir*WXV$M)zGeGdyC_Ad;$iAY9(-X7 zmmxDlV@;1?aJZfHQ{qI&x&kqk6ol@xA^Wo-D0#DDGk*~b$fgX?k_1PTxYl|v{rm(@ zg45BWvr#C%w?L&O8?JRUI*)&x>I4S74#ZbQDFY1VTh-5OVlVBu`kbBYrNEsvC(dR;kF4;dGQTT7Jvj<|aQWL$|IuF%C;!=9oL37gH%2Qixf${A zJ-j*z95+HEB9RGuB#m86?DJwfkaM_%MYJlP`8e&_?;XJAAbSf*m&uP8dggcntB?%E z(vcg5s5$T+!SOQTr3zb!FAqR7f}gixsDe+?uxGa!(}44C!$LmZiP#6jX=?7t)PE4D zI{ie!P3Py~ud}VW89v&VLJr>6i(&Wy^7w(71P$CP91w{HO&VTdZ zg(&4|&FO1EY8^M2zweG{(+>WGb^R%F^20eExXo@O6E5%g@cj?Y|#? z3MdK)nZ2q)1-7Mv*u6~FU^VyN>xPk$U*lN4i-NkX(_&haB*H5XM_^2|K#!qbom-!#H;e0OTR;!`1 ze3TR^@>f6c%Jk256FxE-z%cb3VZUCKL+G;aDV*{o_xAd*Qo|GW43Ysvk-KV`D=xvn zl?RjK;w8}TnVbt-q{A`};JzdKLRrkKgre+~l~|x?SmWK67`GFiS~DOJlj9RD)rh z*b3tlq2JN=YrKF1Ft~0C+qpZR*(Gy-uqTrp>3`%q0fqhq01zpgthp{oPi5R)5QY)6 z5MqY_-I5~$c7=M6XYEMaci=0p^<ulNfGS^rbH2>P2mv-chhnf8UDT7Bu#%-@b@+ro2{ zlU>jDhhcmDxsb-sF)wp%M5k~lfK0Ue0Hy_s-+3V{k_gEm-)#T)4)w}EE zQBucCa4E|iwF?(Bi5U`Hahz2T-6d>>3UUhzm02l3^UcjAUA-V^>#J0)>Ah%o00973fvu`C>8Sj-_JnnKFLh zrs^-TJ_-wcNf>ANilw>32LBmXv@e;jk-n+_RV)ZfF(l@DHg};o3nXAY!CAb(%$?qc zP+gL7N^Ee(YsRlHUGsT`g>8$3!7Z)y6rmS%n|d4isHkcfW3@m2ykS!I2l&ktF{cHS zmTkSTwrAV!ry%B{Af!EX^rsRl;%UwRTl|azgv2Xw+Z@03Wi(*%6c!e?W6OhfDy)fp*sWg^pZVEJdBMVg*{x&*XfLVHvj|jx;de6Mdo9YQybmYR z!T%O?i3UdEg@uI)*$hd*kECQ%YNYD2C<7w(DxXPXhHSXQ8x;6RTB^Z1ZT{&kg^wq%LkI{a!^TOPo1a}PUio{sK&>c(|5TmbM*h5O}OX67E=wgiPO9f zbbl2U6cwf4G4E6snP|0`d);FpFj({VqXWkAX~r)|sShl>KWrnG5?I6mnB6X%94Q&!H9u6K z8*ul%V%GKd-(kq4_E!T1#ZS4pRzE-92kt>D-{oj$esBIuUf#2OGRp1O^~llEY%yXx z-)|6>htt|frDJ#D;p}wrmdSyT{aIHy`3z#iYcQJ5EvbjaJYs!T@?m&Y_9(dc452Is zwT(mHT1hY+9{oS;y=OSr@Bcqs8b)@KkgTkb6++6)O0p7>m8^silI$&HmsupGkWsR- zSIR0Qk`MgO)^+c?^LOKWe2+f$_I|z2^L&oSc%D9TJG!YeB<$!f zkX#J2l`zIMmoI@d3mCSVdy$0QHMb!7@xF6E>p{JIFTvTp>%)GcgZlU+E!&?VN}6_B zWuI1Y!Hch!paZxse&robc8+GLcAkT+tu!8%S1ZLYkGpWkhbAqH`=Kkh_Id9NTd%t+ za-ZOw-CmBlN2aQYTb)Y_Q+>#36*^F!uwkIDuYdmhm6E}G_n7Z@Vk0%Pl$Mv51I1S6 zT=l-CqOz-9QjzrTf(rLuGMSb8KJrJ4g~xgv+xWlr7mgCd0#Up|k4kgmXBW!KYeV8! zMIFQb1yZX^FyloMFJ)+8Ky5U{NB*SelKDnO#7C;5o|dHp+lP+2%B168o4N@l9lf;R zEX|{pvebS0kSWMXlrRPP`FQQejvZ@ZyZIeQn~)4ROKY7Id$;XMv)Tqemzg4%d%C3G z>}F@$@gJqV+H)VC?oU_-I|P(%A)Ghk6*TvlWZ|-4F5>yK`*g4H`R50j$sf^#q$lm8 zDnIqsb>rtOYO#~e(JcEZf(i8&ewE`ukp*L9lcS_k!YIJEOK2}3BPh5ILE+Y)MKmz| z34X~)C-T-fLZ58d8e?#b0GJ1>yFW`?-X9xTKd z*)hd@+?893-@C@uIy5Vbj4i9pdIO-~o#S6q@-n<5+?5w?hf3}6Jo9;(z8edbi{oaT z$^4DHsw!vctIhrmSjGHBP{XmSo_k(-=j4`WX{!KQTmb=_w<#`t=S~y4eD6PC zAxAy_7tW1(JkPw^@iAp2#S(H zEjsbD0&_b* z_E?fP(Wg;tzEJQHUB32g>I*->}IN7Aib9tcHYWCB!{<+`4p|At*k#r>`C80~O$C2nc6>$wq4rG(Z z?!aTQwdrtW%esJFK%7J9L#WaskF758@~3Jj@?^{J`#< zGa6iDx7rG&eE(%-mKJ-iGozpph(41b6AC#qb*-7d8p_0Hog(La8dZY zmDR(pE4d>^#YULh9hBA*%@SI6MS?k;+NR`!*@qOp*zHBHrO8#OjdGn?ibQfgZClhH zxA)}g`BK2J=1^(Xe&v_!p2jmJgMwA|$sJ|RV~Y8dNo>1N)i6eOW}f_q-EwQO`ge+f z7UQD@?6Ky1Eq9AP%|F)UxGJohQV`rS;k7mvD*8hGJ5=&Qa0BHUX?a&~MTx(ATv&MW zi{B0-uKS(M^i{t<-|UmL7E3h}^uQ*szqsGH#Dj-wcLVN}Swief?fhykVp}q3gTli7 zo4%aCV)jz+*^?F`y8`P_vM^HYO6~~G;3|K?aLa?DtJtn(eyq0Q;&UXj(+AxXHqG2( zZKX^E8AGX9K6Z7T;+D;Pf7GamJ-*F(z2c(N?~xm!w^}|_ql{@ebX#t#yxTU2=?8X0 z{fgq3RRqN9AMa%I4-!5SqT*UN8(u`O7HA#NFh&;IfM%QbDf_!O-e;t$&1zkz+6gy8 z$I)8unC<@Zi5e&VZT`TnMU0>hZP3oUjt9WAE;jAI6tz7qIj?_zf9Iv7gfq+gyb4R|v5Sil7ofk4BRkce=yv6hq~pM3Tl_T` zAXuDUjp3`Dz$&D0&VGGo8dF2EE^KdZM3<3zSFCBZefo!v0~0TAenCM{SSC*SYqj-P zGuywct^f5ku8%Al=d!dI&{kh3zE9*Y_ z`u51jh%_xTEyjsSuZJkk$@5)1^Z8D&;&vyA;R|YKCV#J|>eX#O740(k;qzNAGLr z5k3eb!4T>;sES@fPmoYtKFIWEq4MZX2gCTZ9_)ngZZdWz#El$S&@wIdQOn}K4|C%DuP76DZ=-T)4 ze}-@W`#ba6cXPQVT)Ey>!j;$cgY&59+NSS6eCrmWa{rgxDF1wTdY;(h-L`$RZj$(s zkceUu9Vg=9Naf3JTUIHjVU%KInb0eAlCnC#0V-OSm$;sa8QExUlrO|-=T$=cTxC{h zRyc|fO&~H8F(&;Q2OweqrTmciUp;s4Cz6)*qE14Xxt4v-zA#M;739Om9SQLvBGt%KG?Yb zxei|ygdeW)sFrI2cT@E=FSb2NtT0=Vs|1uoWb@x6i@(pNh>T^2vN228(yFi%jxNlc za!f@D|Kt71%x*nLHfD+hx6m(1xZ4TBBPa68ku^iP3RxNRw za)0DRd+Y3v;OWu6KIPrI-p8Da@w{n_)$D8vX`%DmyU#UBL^fGUvnEM;{bb9g6Fa*v zv_U~6-~iVG_0(6~OXN~Hf}Akx#w>c_mul!20oy>oL%a5dzu0MQpFK9_)xKMjIa(yY zecD50d~f*9%jBD<@~Y5@XZUW+>aU@gKr_yYE+a3^HR5NI-OILv)Gc_?yJ^_8p0l&X z%&l$^+ns1p(0#tbMIKZKW!#YEP7;pszl*nthJB(r`Ul$4HuUiu;EDnIJZso~&4S!+ zS8ylA6tNj&D|nv#L0zS5!8X%Ftf0zP}iDf zm9lv4O8N8C{cBTZo3-s+q^SQjzkR#@<<->q0{F-|qlzGO{p(vj?c>4j-IDQ)yxB_V zQ7s#lAD*imk+*rvM7AUM&goA(IW*&>I&DhSPOaoAW)~p}q}-jG zo=*Jr^XJ+Q)SN;`A5D7S{Oxp)Q%E!G?=3;bzyO-$zlc)aUsJDWAD>D<(DEH`3@7@~ z!b05ehrQ*EIK;#hul_5fNsKwVA%sflU$?o4G%NLx%bNoo(?8%CiQIpb$NG8yTuame zt1{#8)s<=-jC)HHcC}RbG*`&a$F5sw=bTl`pW7F)dEiRgIaAYv6v2qu83)8|`uh9z zVj>rB0G}7j!Ewa`Bh(!%eHZ+$C7<{^r`W$3MOuq_!Q4j|bVv1J!J{^70w^ZRb?neX zi^1)VjLCC%*Iw6|d!hjNjiO2XopfLhg*wagQp~V$dI{YVBzCXEa1E5x0Z&=!*nIs6 z?rrZG9c}G*Sj&pu{H`R&noZrKHkNqaOg&fE|CFC9E#I;I8h#EOl4obQOBm&t;@h~@ z&(A2~jpd|JJgkj+#CRiBF4k_#yv%t2Q8Sk2Xg zhQSHjK#g!>?Mooe@+h7Um3jrTUnI-f3nXy?M7@KfT>feP@5ZW26jhu7$1C_fwL%X+&2bt|0bSwu3@aWO*9e23> z23S|L55LPR(_YIq5_}LMoR}Z<=CI)Os&^(3R1T#Ors!s6&SgTa(qDGI&%^B95&QY4CT61$C%40&O|A{^kxV0xFa8fVtcv( zHNS}87?&4K_Jt1l(ogfDX!7FE%9GpuL2OaTif>&;Ng2E+?)^0JtteaUdLR7-?boE8 z4$ufE`bzN{?({kQlP_A;3R+c2f0C+HJ-fLCUL(Lu?a^N?ZvH)pV@|_87G>5 zVhjGM!@)%)^r);ZD|2s-I)JVB7o}wJnaHN`y=Uc?`}EGP|J`zw1e*E{t=XA0X}bP| zpu1|6BS_Xh$GlW#{hF`kTvg%^(!MX zcgDzFCoaG87^d@V0-Vs!naXD$J2|*(Jvty38Jl+Tae28%-{W&f&Oe_#n>%@{Mv06DLnc`e9Odz7uIdmvfr21CSoS& z)#gM+htHKCK8Eqp)PS+t;(3o=s;RnE>+7f~P?_U$%;f>r5ZzidT2eEC#PJf;IzN$6 z+HI%KVLodG1;tc0Dpt1bZ)ZH^e1V&y?{Ji4A=^o0`+#K2drO>S(U-+i$CuZL8|m-@ z_jb`6#z>qD7*+K3J1=HG$XO_SRPHk;(}u)sEt=HyHb5y9LY5THWAk#NOv(Vulvhh1$<>`#ysuNMaqDOR z_X9RK14QREZz)rlt;>ksHBWBS5oK@hXLl8m&zt$Ngg}Yj_!KAZ!@J-4l@Kn0GFVYC zy`sd!_@1$u*)jD(i4B29gB4IHEyk%*jka|TuLw!xca*tmBJ*Sy8@lo&9_DD@ADvP} z&3pRYy<>a+ZejGw)gg(C!C2Y7DjixpC6-MQ>p!L&T4P!!ploFP8-q+IqlPiNy)rRZUtc6|~xhSNPKC6_qYNiw@0!0FM>MF6#en0A)xQt%~ zbaQb`aLmcYLFZ?bFYZVZCrRz-~MK_xI?u2245cr-7lh zIH%@h2PL`W{XPFWk%m=T=hu!oHID6dTsBq+(u=)$G}OzKV#kM2NH z7LzjC{;H#+sM@hAAyN*R^0$hv(Z1H^rmv#*3g1n#9ZZCDrhZMzSD&;SJEFC{YFFy_ z3bBu0mq~wKQIR^iO+k>Et@l~@Ym#Dz?EIYGStG&S4l^)I(lqjpdzD`NQo1|P0)+g? ziSwtX`1-DMv#)ypeSGdAl5H`JnKUMmxZ2kV(2sLKDCGe$`@Y9Oh&OhyGX)>z?G>hc zF4q2pI&_Cj*#L#HNv+bC?JK5h{!GqH0Y=raeC#U>@KLSvtZ9r!tn-uRCxye+c`OZW#58Lj1gMfGaPrWf0fvo5@c6xNj zRDd2qr-QFd(+}rn)u}y9J}CTH@Fz>e?4Zyk_$R@)(QQx$D`II$1CH+wC8mvR1iT*(eNJ}o@CA|3A_XED_QLnDN)?(>gn|k4QYhU5eE2~tiU39QK|0TO+`vE zDuw+-YgVN*vHYt1?9w~g#Z8R=2rs4E<<%uQGZ?hGH>PFzK#^uE6OkDJsO=;wf%V)?L-wyAG!m5PcAr}pQ3M9T#1T%*^8j3;PxcUJ8gqAPvc z*rdu)b^hB;(HzBW+CCBi`HsF7jXQjq?;FnS7r*yR#g}|R;Q$Z)MB`V#wKy#v2YdTh zx`A~?u=BW3mL}22uWh?c-h9XCQ+ipWrD~)mU_Qg=7rn5aJ*5M-5?CjI4F^5H_@i66 z3H4Y$pE=E^`CkM%gfjV!?(~YqWCu97&k$cezgW>@E>c=nb_*?Y0iE#nqzx3m%VZRMa}Ge1)y z)06kgfQaFPG?gQ8y{R8f>HLZ+h@jb`d`y>ym5x6#68wxN`s|5Sh7YH;^TgxZh5>%; zJRLUELB*MRWLT|@Emn;~wvOru1(ozKZrw@7r-g+tp|89z#6-#I-W5(^PC;Qx+kQl6 zhOQOB&xzGO>^QrUK^++gCT86>h*Auc!&okDmJkC4ao~t*Mf3>AaZkAnoNta9xD7yN zTUl{c@5yPR+1D)cZk<8Gh2(sdAo;$Bes$Zkb;xx0GV>2K9x*H+3s&rXbmk8THaD3O zBz$MwNHq`t_mAoKq3YLwmTKRLz285FyXq0`%Q~ivi!GaA^7nt*uq1L(qcdjdVGgIF zLx__htyo??(^mu8kd4=jMaq8~Q(|52`n+L2VwFzAETJ}J$Q|GI@uQ(FH@)=!mAj8~ z;_tnAnsD;N$B*^DIM`o1kJTfEn#x`qdcG%s_(ev7xJc4jI%@cd^mFaJA5ga{UWc?D zmnjm=4^q17Jl%oQ^Fg*12Ak}AI`@(11;m*jw_w+$7Z~P{hq{}X$<%lxT|2MNoavZ- zA7Ki%sNc!YK}%2fi!sUw9L{=X5mlDzaFNChBXwM_Lvi zmXe6(0dYA^RUh*a+6lNCwrsSHh8uls9s?E91%s$TVcu+P7CP+2`LKL(VULPxIA0{F58e1yzZ=%Xl575a-DF&o^rS0zFggdb( zi{WU=xVezPuLl{xPr2-?qX78Yy)26dAYQ{f}-g~%7 zE9=(T{;A=!4YV^Dy{n$A_ugJCbvGrG2pG-cGi}r_ z%gZCYG)~3Q^4M=wDL&}t^9Y=IWo5Zi{zasAl;&@s6zOi-YZsF{_ECra^}P*o6-GB8 z+kv|N2P55&2#vg6r4Y*HKYt1PUX>Ssmc=TR&#Ma~xTLt=MpZMXrY7TtKz9LX{C|tL z|J?))d4OsCR%DYHFvXQspZYt8Y4OdP0{X5#d|XiAXlqOGy=rGZ1EsL~&1qJOsf{d1o`>ks``0;PGGNb{;+4;FsH4a}N+=PpNfM2;~8iLGr;& zB4R@_e;KRKR2RoWHHpkPPxOB&mhHt(nP-g=%A3!hh$+> zg5tc_Y4e{En@0MJAJ&rkA;p>d<|1JcNA{u1El}{xYw&t>s_OQ?tsT25PYJY4x!&5C z%>&W-7eLtKhbk*7PoGWx{)5XiPh9&fw@?Tu&3Cdj4kzi@<-$S7Uw%8N2TI*rzBka_ z9h`VN^=XV&cNq!o2O$+eg+KiWQ^mkLfC7i|*Ia~%SO~yxB^j^E{*F=MzkLX`IcihA zEw*swDzimwwzj>y?Ngg9*Ad=hTR84Uy9;|8(V$ED_;CSPJ#dbF z_FFG5cL3V(r)R!HaW)VNtzUEfF{hIxc7&@wEc&YE_+pA_#{%g)jy5Xv+OMG`xjKT& zpz0rONwDjnb=AvuXYb6gs(&{gwBi#oB!Q9^ zQ%P>1F|#;%{k|Hlf1ryW{x$H`iDgg8`_CRfHgD*Vt^^mUV6h|n8wG>+PJ%mklcCbQ zf^rT~k@iTC#7jdp6BDnHShD)ydik??y|ngYTN{6UQJw$(^RU}iQ*#dmFHbywoZ6)8 zaZY>Jua_MZHVd9To5!Oc!ki`|zXPX5W03qCVu(ZXKA!krjIV;~1`t&qmsC#w9Jq|@ z-#e5!yD{^Gyd+iY5!xs=w=M;J3XD9=>m^_H!lZ$Vi<@fc4@wOlxEjBV=1kN$b5DXi zzQeNE2WS=I*5ug%Mq|xLZ(CpXk9;3Jc;XKnv&X1N1NqFtf`Uz)p8Z0`jh959y%-d9 zaf>3SKLa6e92ZFv>+MfJp+d3^;{$&Z_T)t>JZfYIC1|d4>H^n8gXkU`f zX9(@!e?Ys3Z9zWgn0^XdNoRszIYas4boFYm?c}OAk^^^d>$Zet3eOpJt^@)g zAV#{tOC0oz`5^|I5+Y+16WzAp;epkB35-(<+HNk@!4+^z)52Sj(ZR_H-Zw@%gX9ha zQ&UqxMl@{dmIIEG%K9+yv(uUzn+sE}dxY$mdsXBxv~pR~G)M-*fcmx(~j} zb3kX(Kq)5_EK}?n)g%Tp&HQlj4)ee9W5eyfQ7b|8Vb^!)LGQ zgO11I+uTrY!=q?Mz`t^AQujM?%%h{D2Yy=97YQNdMC?1l*NRndP*&Rh6}#`+)vF)o zRhf&tWCuOUm)I z*BePflFRTiJ>~99r*=%K#;~2CauQ3mE(t&GR5FNhfP3{7~hY_cpy zS?~+c`&Z$TK}RCvPV^hE6BOw#Vq_vR$wPk$z1Kjp-c$@p6lR&yN1b?Yc!h07_w*@3 zv-cUv8g1FWi$`rzb_WycBEnLISif&Uw%FQ9wcW>stmAj`8w*c-c5%2mgW3*x{SM^Z z8%_d=L%x6Jmj{C=E}5l843l(<{`5X!ybHi=TB-_nDoSux>K3Abfi2SiYKWq6+|AT) zxD+B;^KRX&+X9xI7~lg*RY2XB_C!Ki_78R2F)68k0IP_WiW~ChKj_7Fk@#bm_4Spa zY>(*go&5>8`1!La&U1m=wrQ`ShQoE)$=-4qYTUYzaYU;URTj$1Zkv*Gu3T5oB9y#8 z%PQb>z0FGQ$6ImYXc9`VPMb_98o-uGGf`>;G7r|8U^kH}R3mx9x8b!YYkt5OAI`jQY1g8w2l{QF3_x`$^ zt%JCUYT+H~63=NMdfj8r<^mU<8NN5}3K3_HZni8AgscRA;SZSV-BirVyKAdHlA1mU zyN8wh4MAdfO4BFUmXvCJ{}ORZRGAQN;43FJ-Q98|{M7q9{-WeIWOcd5KybPh!%!9i5<({F$S{~EAj zVPW~}TiY>35v+Iv{2ZZMFE5uYVBDl?+qWcyVj=X9Z;FijH|Xs?;Xr8dfJA8_-^&9+ zQ)(`v*!-h;*LAjcl>RlCRKq~=p|9_4y6pa#xY389kt3Uk;Ge+&rkuI_HC22Ok~8$O zQAi^1GEUsrq~1vaivOdewfRu~tKe53dU{r{*L2!(lR6qxb8WMlT4nxLee>`32J_2Q zuO^I5ObCjfU+)q0e6$}m3UC2Ym4-9X}93HVa}F!q|!|r~x8_lX8z<+6**i{%j+{gvpr5mVnET z+|&BvH~0$a1d=yi_cqY0y7%hqa823*t<@W$>~s;HvQ8VNCjT(mRdUa6S6Ozgo#G`x zHhfrIT2(gZ32fkdQA6u|tSSn*9c*5cbb)n#PP)ZLlcd6i@0x3YjVCQFdse|BhVcKD zzGwC)-D%ch+iuQhR&9q%QbFRrO%*@n`DJ@yKeQN-t^w_S2TVJ^WB*2KI|~8vn?c4! z@C5fdrXE4kaCN8@H6nWv?iRr4FGMkV>2++tGnw+~J#G2|(3?eYNnQI~1u}Y;n4Zxx0j+HZ z^bg)3mi2x{-E!_c*576Q###)~g_x#@-%E%#-E*Id(uWhn*)WjKz{<)>gvqVqVx74& zbl6ZgV1~q6l5Q?@xUw+t7I;zOlTT?cBaSYBxWuP#AcEDM3COQEBoxtj_5NHjas+t_ zF%~+3|D>Oh!mn+C1eQ*``RgavavOL=z|r<=II+lU#YT>}g+?YFg&+#~45@2uB(h5q zXut&-Z;pra62BDZEA#z%)wDQ`-7DH)^l2@nW4~tCfLZ~XNcS&E3wo*Rl_SLHWA=F3 zq!71hk4l`)^BA*q$gbD$P&xUIz468yQ_qaczQK4jjG~g*BHuNWJEoRBk@In3c?WFC zzAq#?l7wy|90JYt0S(rjaOQ;)Q%%pVTqPsHBnWbphJp@IhM=UNYhZZl4aEr2{wlsk zXI*%TX}&AI{q2tQ5R0Z$E1+SrUBrgf%0Ufsfo^%El`7`7GO5O`n7N%SHjVVEAuAiR zTi11+6^<2=oZ$n>F&aPGrktvBK;^)aFO5#CeT`sVorb0PW4P|{T|)665fYMgV3=d+ z2ww!d;c4r0*zLSagzyBBo|xOAFJNF|Qi;=s4Y&mf`XD};20C;AmbW3nMY%sr6kz{N z7{c5HoT-gp^Ecm$wy6CZQp|QjxTOX`t}SBCR$zKH^d zP`pE>0DvK+VGME*TxM?{=`J$@*iH_i5s)7tDuJ#J6#qPQ>~SL!Oq5{mJW+tyJ2()9 zM+3F2Bg*W)UmX0$GAxVNP<2;c6b@QKGrmocM$Pp&>m9IqIuu@{05p8oocX2tBhr#& zPQHGiE5FBpC%GeT$dWp+?n{cORWqzRXsUy+kX0T=!vmZG8)#V2S_6BA(ElW#vSa2u zsBeAu@b*2T>L2%1W}be`Ao)eeHu6MRA|{I+U-ra}^jXr@FF&1x&=C?Q-3_gRonz+& ztcRVX?ltWW%!beB!2?TZU?tw#2%+%97_2%{XhIgi+IgX|L_N_4Xe65L#J%%M0*UwV zrLda0aU^NgFe`>j)xQ?@e{$Rq49b6u+{129lnQn4!;wKxy|F1d9N$K8xg*{Fk#x9XoNlX`t1mmRbz32!~fe5Yy_QonylK4F8rFZ@I#ppM~VSn;k_ zE`)ROSSLyeu!+?GbAdv~-rvM*8Q`f(;(`MjZPvOG-%7nBhcb3wwtOA-P3QAVs1`v= zgT=d=aj(nZyX26m2?l@I!!x{Gq ze~|!70n{9iZ__t4ghm}IBSOrA7hme8M<1?KZFbW6%NuCe-%kJNUQSL+EIl7chzVt@ zHoiSYfw_YGtu9Vw*R~17&j%+q)~qP?6=xOoD?Z}TV63gM?vpgbAx(>Mm;!vT!J(gK zcjJr$nk2p2r-!=U<074a&LWPKtwhA`{fE0-TOmb(m+&^4_1v$i2j6+AMl(-&RDwRU zOVWDw4V&_`a;k-cicq)bJ`M8SQ-F5KU6qC}6}~c*b@mnd`>?p!Wws|5h|U)HV}E5` z6B8C0wO96Lg})(mM7X$K9EkebpOj4+9`*eoKk&zg6Hl9j*h*kf8PNwpu<7&0Z#yE* zZxn{acK@R976v)pErb)_+D!d7IK1j!G@O44cgw>Vd5xF=TM2J)xvwt@Q#>rw*u4BC zRpoJl;l-49YW!J;@v)Hm2`5(~dBlzU{PP!CSUQ%eQ*Oij`Z=lhWMz{_o^d9*&9~Z= z2q$;gmq8{6BJONB+he%|XL_Rx8{9;uRaVVmVWzTp{9fUd;k|vj{bS3XM#tDb}m;$r;K;`F6)C zp51=Iaki*o&u$7qJ6i@dkqbI6aW!XEw6toDCP(YtQ|x9c+jJFI>7Vug>i_8}r~0t? z#S8j6g`Lhhig8k$uT`UBd%wB8Mu)KmRW*AWW4JOn{OjN-$3ws9pPJs6{g?WgSKQJZ zZCIRMnU+0Co7#v?2*a+GjZlGY-I@EBRIA-AvSV}OI9;`LQ(5mM^nxlO;&LljOoF0P z5)*lXk9FC__)^vVZ;jkxt~@klFp4^3!8mv2rtX-{r18e#

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