events

MCPBee Events Package

The events package provides a public API for external tools to publish events to MCPBee's learning system.

Installation

go get mcpbee/pkg/events

Usage

Publishing Tool Events

package main

import (
    "context"
    "log"
    "mcpbee/pkg/events"
)

func main() {
    // Create a publisher
    publisher, err := events.NewRedisPublisher("localhost:6379", "")
    if err != nil {
        log.Fatal(err)
    }
    defer publisher.Close()
    
    // Create and publish a tool execution event
    event := events.NewToolEvent("grep", "search for pattern", "found 5 matches", events.StatusSuccess)
    event.SetProjectID("my-project").
          SetSessionID("session-123").
          SetLanguage("go")
    
    ctx := context.Background()
    if err := publisher.Publish(ctx, event); err != nil {
        log.Printf("Failed to publish event: %v", err)
    }
}

Publishing Error Events

// Create an error event
errorEvent := events.NewErrorEvent("build", "undefined variable: foo")
errorEvent.SetFile("main.go").
           SetMetadata("line", 42)

// Publish the error
publisher.Publish(ctx, errorEvent)

// Later, when the error is fixed, publish a success event
successEvent := events.NewSuccessEvent("build", "go build ./...", "Build successful")
successEvent.SetFile("main.go")

publisher.Publish(ctx, successEvent)

MCPBee will automatically detect the error→fix pattern and learn from it.

Batch Publishing

// Collect multiple events
events := []*events.Event{
    events.NewToolEvent("test", "go test", "PASS", events.StatusSuccess),
    events.NewToolEvent("lint", "golint", "No issues", events.StatusSuccess),
    events.NewToolEvent("build", "go build", "Success", events.StatusSuccess),
}

// Publish as batch for efficiency
publisher.PublishBatch(ctx, events)

Testing with In-Memory Publisher

// Create an in-memory publisher for testing
publisher := events.NewInMemoryPublisher()

// Publish events as normal
event := events.NewToolEvent("test", "input", "output", events.StatusSuccess)
publisher.Publish(ctx, event)

// Retrieve events for assertions
storedEvents := publisher.GetEvents()
if len(storedEvents) != 1 {
    t.Errorf("Expected 1 event, got %d", len(storedEvents))
}

Event Types

• tool_executed: A tool was executed with input and produced output
• error: An error occurred during tool execution
• success: A tool completed successfully
• warning: A tool completed with warnings

Event Status

• success: Tool completed without errors
• error: Tool failed with an error
• warning: Tool completed but with warnings
• pending: Tool execution is in progress

Metadata

Events support arbitrary metadata through the SetMetadata method. Common metadata fields include:

• project_id: The project context
• session_id: The session identifier
• user_id: The user identifier
• language: Programming language context
• file: File being operated on
• line: Line number in file
• framework: Framework being used

Integration with MCPBee

When events are published to MCPBee, they are processed by the ProactiveSuggestionEngine which:

1. Detects Patterns: Identifies recurring tool usage patterns
2. Learns Error→Fix Mappings: Tracks how errors are resolved
3. Generates Suggestions: Creates proactive suggestions based on context
4. Creates Dynamic Tools: Registers new MCP tools for learned patterns
5. Stores Knowledge: Persists learnings to the knowledge base

Stream Key

By default, events are published to the claude:tool_events Redis stream. You can customize this:

publisher, err := events.NewRedisPublisher("localhost:6379", "my:custom:stream")

Error Handling

Always check for errors when publishing:

if err := publisher.Publish(ctx, event); err != nil {
    // Handle error - maybe retry or log
    log.Printf("Failed to publish: %v", err)
}

Best Practices

1. Include Context: Always set project_id and session_id when available
2. Batch When Possible: Use PublishBatch for multiple related events
3. Be Specific: Provide detailed input/output for better pattern learning
4. Track Errors: Always publish both error and success events for the same operation
5. Add Metadata: Include relevant context like file, line, language

Example: VS Code Extension

const redis = require('redis');
const client = redis.createClient();

// When a command is executed
function onCommandExecuted(command, input, output, success) {
    const event = {
        type: 'tool_executed',
        tool: command,
        input: input,
        output: output,
        status: success ? 'success' : 'error',
        timestamp: Date.now() / 1000,
        metadata: JSON.stringify({
            project_id: workspace.name,
            session_id: sessionId,
            language: detectLanguage()
        })
    };
    
    client.xadd('claude:tool_events', '*', ...Object.entries(event).flat());
}

Contributing

The events package is designed to be language-agnostic. Contributions for client libraries in other languages are welcome!