feat: enhance AI extension with streaming support and new SDK features

- Added support for streaming chat events in the AI extension, including new `ChatStream` functionality in the LLM providers.
- Introduced new structures for handling streaming events, such as `ChatStreamEvent` and `ClientStreamEvent`.
- Enhanced the SDK with new components for managing agent workflows and improved error handling.
- Updated the dashboard extension to include real-time metrics and UI improvements.
- Cleaned up configuration options and improved documentation for better usability.

Author: juicycleff

.gitignore

@@ -18,6 +18,16 @@ test-*
 *.a
 *.out
 
+# Go compiled binaries (executables without extensions)
+/forge
+/forge-*
+cmd/*/main
+cmd/*/*
+!cmd/*/*.go
+!cmd/*/*.mod
+!cmd/*/*.sum
+!cmd/*/go.*
+
 # Architecture file
 arch.md
 

extensions/ai/extension.go

@@ -14,29 +14,34 @@ import (
 
 // Extension implements forge.Extension for AI.
 type Extension struct {
-	config     Config
-	ai         internal.AI
-	llmManager *llm.LLMManager
-	logger     forge.Logger
-	metrics    forge.Metrics
-	app        forge.App
+	config         Config
+	configProvided bool // Track if config was explicitly provided via options
+	ai             internal.AI
+	llmManager     *llm.LLMManager
+	logger         forge.Logger
+	metrics        forge.Metrics
+	app            forge.App
 }
 
 // NewExtension creates a new AI extension with variadic options.
 func NewExtension(opts ...ConfigOption) *Extension {
 	config := DefaultConfig()
+	hasOpts := len(opts) > 0
 	for _, opt := range opts {
 		opt(&config)
 	}
 
 	return &Extension{
-		config: config,
+		config:         config,
+		configProvided: hasOpts,
 	}
 }
 
 // NewExtensionWithConfig creates a new AI extension with a complete config.
 func NewExtensionWithConfig(config Config) *Extension {
-	return NewExtension(WithConfig(config))
+	ext := NewExtension(WithConfig(config))
+	ext.configProvided = true // Mark as explicitly configured
+	return ext
 }
 
 // Name returns the extension name.
@@ -72,21 +77,28 @@ func (e *Extension) Register(app forge.App) error {
 		e.metrics = m
 	}
 
-	// Get configuration
-	if configMgr, err := forge.GetConfigManager(app.Container()); err == nil {
-		if err := configMgr.Bind("extensions.ai", &e.config); err != nil {
-			if e.logger != nil {
-				e.logger.Info("using default AI config", forge.F("reason", err.Error()))
-			}
-
-			if err := configMgr.Bind("ai", &e.config); err != nil {
+	// Get configuration from config manager only if not explicitly provided via options
+	if !e.configProvided {
+		if configMgr, err := forge.GetConfigManager(app.Container()); err == nil {
+			if err := configMgr.Bind("extensions.ai", &e.config); err != nil {
 				if e.logger != nil {
-					e.logger.Info("using default AI config", forge.F("reason", err.Error()))
+					e.logger.Debug("no extensions.ai config found", forge.F("reason", err.Error()))
 				}
 
-				e.config = DefaultConfig()
+				if err := configMgr.Bind("ai", &e.config); err != nil {
+					if e.logger != nil {
+						e.logger.Debug("no ai config found, using defaults", forge.F("reason", err.Error()))
+					}
+					// DefaultConfig already applied in NewExtension
+				}
 			}
 		}
+	} else {
+		if e.logger != nil {
+			e.logger.Debug("using programmatically provided AI config",
+				forge.F("provider", e.config.LLM.DefaultProvider),
+				forge.F("providers", len(e.config.LLM.Providers)))
+		}
 	}
 
 	// Convert to internal config

extensions/ai/llm/chat.go

@@ -108,6 +108,14 @@ type ChatStreamEvent struct {
 	Error     string         `json:"error,omitempty"`
 	Metadata  map[string]any `json:"metadata,omitempty"`
 	RequestID string         `json:"request_id"`
+
+	// Block-level streaming support (for providers like Anthropic)
+	// BlockType indicates the type of content block (thinking, text, tool_use)
+	BlockType string `json:"block_type,omitempty"`
+	// BlockIndex is the index of the content block within the message
+	BlockIndex int `json:"block_index,omitempty"`
+	// BlockState indicates the state of the block (start, delta, stop)
+	BlockState string `json:"block_state,omitempty"`
 }
 
 // ChatStreamHandler handles streaming chat events.

extensions/ai/llm/manager.go

@@ -465,6 +465,75 @@ func (m *LLMManager) GetProviders() map[string]LLMProvider {
 	return providers
 }
 
+// ChatStream performs a streaming chat completion request.
+func (m *LLMManager) ChatStream(ctx context.Context, request ChatRequest, handler func(ChatStreamEvent) error) error {
+	startTime := time.Now()
+
+	// Get provider
+	providerName := request.Provider
+	if providerName == "" {
+		providerName = m.config.DefaultProvider
+	}
+
+	provider, err := m.GetProvider(providerName)
+	if err != nil {
+		return err
+	}
+
+	// Apply timeout
+	if m.config.Timeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, m.config.Timeout)
+		defer cancel()
+	}
+
+	// Check if provider supports streaming
+	streamer, ok := provider.(StreamingProvider)
+	if !ok {
+		// Fallback: use regular Chat and simulate streaming
+		// IMPORTANT: Set Stream to false for non-streaming providers to prevent
+		// the provider from returning SSE-formatted data that can't be parsed
+		request.Stream = false
+		response, err := provider.Chat(ctx, request)
+		if err != nil {
+			return err
+		}
+
+		// Simulate streaming by sending a single event with full content
+		if len(response.Choices) > 0 {
+			event := ChatStreamEvent{
+				Type:      "message",
+				ID:        response.ID,
+				Model:     response.Model,
+				Provider:  response.Provider,
+				Choices:   response.Choices,
+				Usage:     response.Usage,
+				RequestID: response.RequestID,
+			}
+			if err := handler(event); err != nil {
+				return err
+			}
+		}
+
+		// Send done event
+		doneEvent := ChatStreamEvent{
+			Type:      "done",
+			RequestID: request.RequestID,
+		}
+		return handler(doneEvent)
+	}
+
+	// Use native streaming - set stream flag for streaming providers
+	request.Stream = true
+	err = streamer.ChatStream(ctx, request, handler)
+
+	// Update statistics
+	latency := time.Since(startTime)
+	m.updateStats(providerName, "chat_stream", latency, err, nil)
+
+	return err
+}
+
 // HealthCheck performs a health check on all providers.
 func (m *LLMManager) HealthCheck(ctx context.Context) error {
 	m.mu.RLock()

extensions/ai/llm/provider.go

@@ -21,6 +21,13 @@ type LLMProvider interface {
 	HealthCheck(ctx context.Context) error
 }
 
+// StreamingProvider defines the interface for LLM providers that support streaming.
+type StreamingProvider interface {
+	LLMProvider
+	// ChatStream performs a streaming chat completion request
+	ChatStream(ctx context.Context, request ChatRequest, handler func(ChatStreamEvent) error) error
+}
+
 // LLMUsage represents usage statistics for an LLM provider.
 type LLMUsage struct {
 	InputTokens       int64         `json:"input_tokens"`