feat: Add Go SDK encoding and error handling packages

- Add comprehensive encoding package with JSON support
- Implement content negotiation for Accept headers
- Add buffer sizing utilities and encoder pool
- Add error types and utilities package
- Include unit tests for negotiation functionality

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: mattsp1290

sdks/community/go/pkg/encoding/buffer_sizing.go

@@ -0,0 +1,136 @@
+package encoding
+
+import (
+	"github.com/ag-ui-protocol/ag-ui/sdks/community/go/pkg/core/events"
+)
+
+// Buffer size constants optimized for different event types
+const (
+	// Small events (typically 100-500 bytes)
+	SmallEventBufferSize = 512
+
+	// Medium events (typically 500-2KB)
+	MediumEventBufferSize = 2048
+
+	// Large events (typically 2KB-8KB)
+	LargeEventBufferSize = 8192
+
+	// Very large events (8KB+)
+	VeryLargeEventBufferSize = 16384
+
+	// Default buffer size for unknown events
+	DefaultEventBufferSize = 1024
+
+	// Array processing buffer size per event
+	ArrayProcessingBufferSize = 1024
+)
+
+// GetOptimalBufferSize returns the optimal buffer size for a given event type
+func GetOptimalBufferSize(eventType events.EventType) int {
+	switch eventType {
+	case events.EventTypeTextMessageStart:
+		return SmallEventBufferSize // Simple metadata
+	case events.EventTypeTextMessageContent:
+		return MediumEventBufferSize // Text content can vary
+	case events.EventTypeTextMessageEnd:
+		return SmallEventBufferSize // Simple metadata
+	case events.EventTypeToolCallStart:
+		return SmallEventBufferSize // Tool metadata
+	case events.EventTypeToolCallArgs:
+		return LargeEventBufferSize // Tool arguments can be large
+	case events.EventTypeToolCallEnd:
+		return SmallEventBufferSize // Simple metadata
+	case events.EventTypeStateSnapshot:
+		return VeryLargeEventBufferSize // State snapshots can be very large
+	case events.EventTypeStateDelta:
+		return MediumEventBufferSize // Delta operations are usually medium
+	case events.EventTypeMessagesSnapshot:
+		return VeryLargeEventBufferSize // Message snapshots can be very large
+	case events.EventTypeRaw:
+		return LargeEventBufferSize // Raw events are unpredictable
+	case events.EventTypeCustom:
+		return MediumEventBufferSize // Custom events are usually medium
+	case events.EventTypeRunStarted:
+		return SmallEventBufferSize // Simple metadata
+	case events.EventTypeRunFinished:
+		return SmallEventBufferSize // Simple metadata
+	case events.EventTypeRunError:
+		return MediumEventBufferSize // Error details can be medium
+	case events.EventTypeStepStarted:
+		return SmallEventBufferSize // Simple metadata
+	case events.EventTypeStepFinished:
+		return SmallEventBufferSize // Simple metadata
+	default:
+		return DefaultEventBufferSize
+	}
+}
+
+// GetOptimalBufferSizeForEvent returns the optimal buffer size for a specific event instance
+func GetOptimalBufferSizeForEvent(event events.Event) int {
+	if event == nil {
+		return DefaultEventBufferSize
+	}
+
+	baseSize := GetOptimalBufferSize(event.Type())
+
+	// For certain event types, we can make more precise estimates
+	switch e := event.(type) {
+	case *events.TextMessageContentEvent:
+		// Estimate based on delta length
+		if len(e.Delta) > 0 {
+			// Add some overhead for JSON encoding
+			return max(baseSize, len(e.Delta)*2)
+		}
+	case *events.ToolCallArgsEvent:
+		// Estimate based on delta length
+		if len(e.Delta) > 0 {
+			// Add some overhead for JSON encoding
+			return max(baseSize, len(e.Delta)*2)
+		}
+	case *events.StateSnapshotEvent:
+		// State snapshots can be very large, but we can't easily estimate
+		// without serializing first, so stick with the base size
+		return baseSize
+	case *events.StateDeltaEvent:
+		// Estimate based on number of operations
+		if len(e.Delta) > 0 {
+			// Rough estimate: 100 bytes per operation
+			return max(baseSize, len(e.Delta)*100)
+		}
+	case *events.MessagesSnapshotEvent:
+		// Estimate based on number of messages
+		if len(e.Messages) > 0 {
+			// Rough estimate: 500 bytes per message
+			return max(baseSize, len(e.Messages)*500)
+		}
+	case *events.CustomEvent:
+		// For custom events, we can't easily estimate without knowing the value
+		return baseSize
+	}
+
+	return baseSize
+}
+
+// GetOptimalBufferSizeForMultiple returns the optimal buffer size for encoding multiple events
+func GetOptimalBufferSizeForMultiple(events []events.Event) int {
+	if len(events) == 0 {
+		return DefaultEventBufferSize
+	}
+
+	totalSize := 0
+	for _, event := range events {
+		totalSize += GetOptimalBufferSizeForEvent(event)
+	}
+
+	// Add some overhead for array structure
+	arrayOverhead := 50 * len(events) // Rough estimate for JSON array overhead
+	return totalSize + arrayOverhead
+}
+
+// max returns the maximum of two integers
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

sdks/community/go/pkg/encoding/encoder/encoder.go

@@ -0,0 +1,91 @@
+package encoder
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ag-ui-protocol/ag-ui/sdks/community/go/pkg/core/events"
+	"github.com/ag-ui-protocol/ag-ui/sdks/community/go/pkg/encoding"
+	"github.com/ag-ui-protocol/ag-ui/sdks/community/go/pkg/encoding/json"
+	"github.com/ag-ui-protocol/ag-ui/sdks/community/go/pkg/encoding/negotiation"
+)
+
+// EventEncoder provides a high-level interface for encoding AG-UI events
+// This adapter bridges the Go SDK encoding package with example server needs
+type EventEncoder struct {
+	negotiator *negotiation.ContentNegotiator
+	jsonCodec  encoding.Codec
+}
+
+// NewEventEncoder creates a new event encoder with content negotiation support
+func NewEventEncoder() *EventEncoder {
+	// Create content negotiator with JSON as preferred type
+	negotiator := negotiation.NewContentNegotiator("application/json")
+
+	return &EventEncoder{
+		negotiator: negotiator,
+		jsonCodec:  json.NewCodec(),
+	}
+}
+
+// EncodeEvent encodes a single event using the specified content type
+func (e *EventEncoder) EncodeEvent(ctx context.Context, event events.Event, contentType string) ([]byte, error) {
+	if event == nil {
+		return nil, fmt.Errorf("event cannot be nil")
+	}
+
+	// Validate the event before encoding
+	if err := event.Validate(); err != nil {
+		return nil, fmt.Errorf("event validation failed: %w", err)
+	}
+
+	// For now, we only support JSON encoding as specified in the task
+	// Protobuf support can be added later
+	switch contentType {
+	case "application/json", "":
+		return e.jsonCodec.Encode(ctx, event)
+	default:
+		// Try to negotiate to a supported type
+		supportedType, err := e.negotiator.Negotiate(contentType)
+		if err != nil {
+			return nil, fmt.Errorf("unsupported content type %q: %w", contentType, err)
+		}
+
+		// For now, fallback to JSON
+		if supportedType == "application/json" {
+			return e.jsonCodec.Encode(ctx, event)
+		}
+
+		return nil, fmt.Errorf("content type %q not implemented yet", supportedType)
+	}
+}
+
+// NegotiateContentType performs content negotiation based on Accept header
+func (e *EventEncoder) NegotiateContentType(acceptHeader string) (string, error) {
+	if acceptHeader == "" {
+		return "application/json", nil // Default to JSON
+	}
+
+	contentType, err := e.negotiator.Negotiate(acceptHeader)
+	if err != nil {
+		// If negotiation fails, fallback to JSON with a clear message
+		return "application/json", fmt.Errorf("content negotiation failed, falling back to JSON: %w", err)
+	}
+
+	return contentType, nil
+}
+
+// SupportedContentTypes returns the list of supported content types
+func (e *EventEncoder) SupportedContentTypes() []string {
+	return e.negotiator.SupportedTypes()
+}
+
+// GetContentType returns the content type that this encoder will produce
+func (e *EventEncoder) GetContentType(acceptHeader string) string {
+	contentType, err := e.NegotiateContentType(acceptHeader)
+	if err != nil {
+		// Log the error but continue with fallback
+		return "application/json"
+	}
+	return contentType
+}