refactor(R2d.109): carve internal/api/aichatbot subpackage

Move ai_chatbot_handler.go and its test into the new aichatbot subpkg, rename AIChatbotHandler -> Handler and NewAIChatbotHandler -> NewHandler. Router.go imports the subpkg and uses aichatbot.NewHandler; the AIHandlers.Chatbot field (typed http.Handler) accepts the new *aichatbot.Handler unchanged.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: atulmgupta

internal/api/ai_test_helpers_test.go

@@ -0,0 +1,19 @@
+package api
+
+import "context"
+
+type stubGuardSettings struct {
+	mode string
+	on   map[string]bool
+}
+
+func (s *stubGuardSettings) AIMode(_ context.Context) (string, error) {
+	if s.mode == "" {
+		return "off", nil
+	}
+	return s.mode, nil
+}
+
+func (s *stubGuardSettings) AIFeatureEnabled(_ context.Context, id string) (bool, error) {
+	return s.on[id], nil
+}

internal/api/aichatbot/doc.go

@@ -0,0 +1,4 @@
+// Package aichatbot serves the AI chatbot endpoints under /api/v1/ai/chatbot.
+//
+// Layer: handler
+package aichatbot

internal/api/ai_chatbot_handler.go internal/api/aichatbot/handler.gointernal/api/ai_chatbot_handler.go renamed to internal/api/aichatbot/handler.go

@@ -1,8 +1,8 @@
-package api
+package aichatbot
 
 // Phase-50 / 0011 — U1 Chatbot LLM upgrade.
 //
-// ai_chatbot_handler.go implements the real LLM-backed handler that
+// handler.go implements the real LLM-backed handler that
 // replaces the F0 stub at POST /api/v1/ai/chatbot. The flow is:
 //
 //   request JSON {message, session_id}
@@ -52,11 +52,12 @@ import (
 	"github.com/ev-dev-labs/teslasync/internal/ai/strategy"
 	"github.com/ev-dev-labs/teslasync/internal/ai/stream"
 	"github.com/ev-dev-labs/teslasync/internal/ai/tools"
+	"github.com/ev-dev-labs/teslasync/internal/api/httpx"
 	tsauth "github.com/ev-dev-labs/teslasync/internal/auth"
 	dbnotif "github.com/ev-dev-labs/teslasync/internal/database/notification"
 )
 
-// aiChatbotHistoryLimit is the upper bound on how many prior messages
+// historyLimit is the upper bound on how many prior messages
 // we hand to the LLM as context. Picked to balance:
 //
 //   - Token budget: ~16 messages × ~80 tokens average ≈ 1.3K input
@@ -67,22 +68,22 @@ import (
 // History older than this is silently dropped. The full record is
 // always kept in the chatbot_messages table for audit and the
 // /chatbot/history endpoint.
-const aiChatbotHistoryLimit = 16
+const historyLimit = 16
 
-// aiChatbotMaxIterations bounds the dispatcher's tool-loop. The
+// maxIterations bounds the dispatcher's tool-loop. The
 // chatbot is one-question-one-answer plus optional tool round-trips;
 // a hard ceiling of 6 protects against pathological model loops
 // without truncating any realistic conversation. Tested in
-// TestAIChatbotHandler_OnPathDispatches.
-const aiChatbotMaxIterations = 6
+// TestHandler_OnPathDispatches.
+const maxIterations = 6
 
-// AIChatbotHandler is the HTTP handler for POST /api/v1/ai/chatbot.
+// Handler is the HTTP handler for POST /api/v1/ai/chatbot.
 //
 // Construction is in router.go (so the dispatcher's tool registry +
 // provider registry are wired once at boot). The handler itself is
 // stateless beyond its constructor inputs and is safe for concurrent
 // use across requests.
-type AIChatbotHandler struct {
+type Handler struct {
 	chat       *dbnotif.ChatRepo
 	registry   *provider.Registry
 	tools      *tools.Registry
@@ -92,7 +93,7 @@ type AIChatbotHandler struct {
 	historyN   int
 }
 
-// NewAIChatbotHandler constructs the handler. All non-pointer
+// NewHandler constructs the handler. All non-pointer
 // arguments are required; the constructor panics on a nil so the
 // wiring bug surfaces at boot, not at first request.
 //
@@ -101,38 +102,38 @@ type AIChatbotHandler struct {
 // toolReg:       process-wide tool registry (Register12Builtins-populated).
 // strat:         the chatbot-llm Strategy (one per process).
 // headerName:    forward-auth header name; used to extract subject for audit.
-func NewAIChatbotHandler(
+func NewHandler(
 	chat *dbnotif.ChatRepo,
 	registry *provider.Registry,
 	toolReg *tools.Registry,
 	strat strategy.Strategy,
 	headerName string,
-) *AIChatbotHandler {
+) *Handler {
 	switch {
 	case chat == nil:
-		panic("api: NewAIChatbotHandler: nil ChatRepo")
+		panic("aichatbot: NewHandler: nil ChatRepo")
 	case registry == nil:
-		panic("api: NewAIChatbotHandler: nil provider.Registry")
+		panic("aichatbot: NewHandler: nil provider.Registry")
 	case toolReg == nil:
-		panic("api: NewAIChatbotHandler: nil tools.Registry")
+		panic("aichatbot: NewHandler: nil tools.Registry")
 	case strat == nil:
-		panic("api: NewAIChatbotHandler: nil strategy.Strategy")
+		panic("aichatbot: NewHandler: nil strategy.Strategy")
 	}
-	return &AIChatbotHandler{
+	return &Handler{
 		chat:       chat,
 		registry:   registry,
 		tools:      toolReg,
 		strategy:   strat,
 		headerName: headerName,
-		maxIters:   aiChatbotMaxIterations,
-		historyN:   aiChatbotHistoryLimit,
+		maxIters:   maxIterations,
+		historyN:   historyLimit,
 	}
 }
 
-// aiChatbotRequest is the wire shape for POST /api/v1/ai/chatbot.
+// request is the wire shape for POST /api/v1/ai/chatbot.
 // Mirrors the existing baseline endpoint so the frontend can call
 // either route without DTO drift.
-type aiChatbotRequest struct {
+type request struct {
 	Message   string `json:"message"`
 	SessionID string `json:"session_id"`
 }
@@ -142,15 +143,15 @@ type aiChatbotRequest struct {
 // after the SSE stream closes. Every error path writes a structured
 // frame onto the SSE stream (when the writer has been opened) or a
 // plain JSON 4xx/5xx (before it has).
-func (h *AIChatbotHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// 1) Decode + validate request body.
-	var body aiChatbotRequest
+	var body request
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid request body")
+		httpx.WriteError(w, http.StatusBadRequest, "invalid request body")
 		return
 	}
 	if strings.TrimSpace(body.Message) == "" {
-		writeError(w, http.StatusBadRequest, "message is required")
+		httpx.WriteError(w, http.StatusBadRequest, "message is required")
 		return
 	}
 	if body.SessionID == "" {
@@ -188,7 +189,7 @@ func (h *AIChatbotHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// stream — emit JSON 502 so the frontend falls back gracefully.
 	if _, err := h.registry.For(r.Context(), chatbotllm.FeatureID); err != nil {
 		log.Error().Err(err).Msg("ai chatbot: provider.For failed")
-		writeError(w, http.StatusBadGateway, "ai provider unavailable")
+		httpx.WriteError(w, http.StatusBadGateway, "ai provider unavailable")
 		return
 	}
 
@@ -208,7 +209,7 @@ func (h *AIChatbotHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		// Non-flushable response writer (test recorder, etc.).
 		// Emit a plain JSON 500 — the SSE headers were not sent.
 		log.Error().Err(err).Msg("ai chatbot: stream.New failed (non-flushable writer)")
-		writeError(w, http.StatusInternalServerError, "streaming not supported")
+		httpx.WriteError(w, http.StatusInternalServerError, "streaming not supported")
 		return
 	}
 

internal/api/ai_chatbot_handler_test.go internal/api/aichatbot/handler_test.gointernal/api/ai_chatbot_handler_test.go renamed to internal/api/aichatbot/handler_test.go

@@ -13,7 +13,7 @@
 // require a live database fixture (the AI handler persists turns via
 // *dbnotif.ChatRepo, which is not interface-segregated yet).
 
-package api
+package aichatbot
 
 import (
 	"context"
@@ -124,22 +124,22 @@ func TestChatbotAIOffUsesBaselineAndAiRoute404(t *testing.T) {
 	apichatbot.NewBaselineResponder(nil)
 }
 
-// TestAIChatbotHandler_PanicsOnNilWiring asserts the handler
+// TestHandler_PanicsOnNilWiring asserts the handler
 // constructor refuses zero-valued dependencies. A wiring bug at boot
 // must surface as a panic, not as a nil-deref on first request.
-func TestAIChatbotHandler_PanicsOnNilWiring(t *testing.T) {
+func TestHandler_PanicsOnNilWiring(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
 		name string
 		fn   func()
 	}{
-		{"nil chat repo", func() { NewAIChatbotHandler(nil, nil, nil, nil, "") }},
+		{"nil chat repo", func() { NewHandler(nil, nil, nil, nil, "") }},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			defer func() {
 				if r := recover(); r == nil {
-					t.Fatalf("NewAIChatbotHandler(%s) did not panic", tc.name)
+					t.Fatalf("NewHandler(%s) did not panic", tc.name)
 				}
 			}()
 			tc.fn()

internal/api/helpers.go

@@ -2,13 +2,18 @@ package api
 
 import (
 	"context"
+	"encoding/json"
 	"net/http"
 	"strings"
 	"time"
 
+	"github.com/ev-dev-labs/teslasync/internal/ai/dispatch"
+	"github.com/ev-dev-labs/teslasync/internal/ai/provider"
+	"github.com/ev-dev-labs/teslasync/internal/ai/stream"
 	"github.com/ev-dev-labs/teslasync/internal/api/apiparams"
 	"github.com/ev-dev-labs/teslasync/internal/api/httpx"
 	"github.com/ev-dev-labs/teslasync/internal/database"
+	chatbotmodel "github.com/ev-dev-labs/teslasync/internal/models/chatbot"
 )
 
 // writeJSON is a transitional wrapper around httpx.WriteJSON kept for
@@ -40,6 +45,74 @@ func writeErrorCode(w http.ResponseWriter, status int, msg, code string) {
 	httpx.WriteErrorCode(w, status, msg, code)
 }
 
+func denyAllConfirm(_ context.Context, _ dispatch.ConfirmRequest) (dispatch.ConfirmDecision, error) {
+	return dispatch.ConfirmDenied, nil
+}
+
+func historyToProviderMessages(rows []*chatbotmodel.ChatMessage, currentUserMessage string) []provider.Message {
+	if len(rows) == 0 {
+		return nil
+	}
+	out := make([]provider.Message, 0, len(rows))
+	for i, m := range rows {
+		if i == len(rows)-1 && m.Role == "user" && m.Content == currentUserMessage {
+			continue
+		}
+		out = append(out, provider.Message{
+			Role:    m.Role,
+			Content: m.Content,
+		})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+type recordingStreamWriter struct {
+	inner *stream.Writer
+	buf   strings.Builder
+}
+
+func (r *recordingStreamWriter) WriteDelta(s string) error {
+	r.buf.WriteString(s)
+	return r.inner.WriteDelta(s)
+}
+
+func (r *recordingStreamWriter) WriteToolCall(call provider.ToolCall) error {
+	return r.inner.WriteToolCall(call)
+}
+
+func (r *recordingStreamWriter) WriteToolResult(name string, result json.RawMessage) error {
+	return r.inner.WriteToolResult(name, result)
+}
+
+func (r *recordingStreamWriter) WriteToolError(name string, err error) error {
+	return r.inner.WriteToolError(name, err)
+}
+
+func (r *recordingStreamWriter) WriteDone() error {
+	return r.inner.WriteDone()
+}
+
+func (r *recordingStreamWriter) EmitLimitError(message, reason string, retryAfterS int, bannerLevel string, baselineAvailable bool) error {
+	return r.inner.WriteLimitError(message, stream.LimitDecisionPayload{
+		Reason:            reason,
+		RetryAfterS:       retryAfterS,
+		BannerLevel:       bannerLevel,
+		BaselineAvailable: baselineAvailable,
+	})
+}
+
+func (r *recordingStreamWriter) text() string {
+	return r.buf.String()
+}
+
+var (
+	_ dispatch.StreamWriter      = (*recordingStreamWriter)(nil)
+	_ dispatch.LimitErrorEmitter = (*recordingStreamWriter)(nil)
+)
+
 // writeTeslaTokenExpired drained to zero callers by R2d batch 8 (carves
 // drained all token-issuing handlers into resource subpackages, which call
 // httpx.WriteTeslaTokenExpired directly). Wrapper deleted per the carve

internal/api/router.go

@@ -17,6 +17,7 @@ import (
 	apiadminfb "github.com/ev-dev-labs/teslasync/internal/api/adminfeedback"
 	apiadminls "github.com/ev-dev-labs/teslasync/internal/api/adminlogstream"
 	apiadminmnt "github.com/ev-dev-labs/teslasync/internal/api/adminmaintenance"
+	aichatbot "github.com/ev-dev-labs/teslasync/internal/api/aichatbot"
 	apialertmsg "github.com/ev-dev-labs/teslasync/internal/api/alertmsg"
 	apialerts "github.com/ev-dev-labs/teslasync/internal/api/alerts"
 	apianalytics "github.com/ev-dev-labs/teslasync/internal/api/analytics"
@@ -738,7 +739,7 @@ func NewRouter(db *database.DB, teslaClient *tesla.Client, mqttClient *mqtt.Clie
 		Drives:  drivedb.NewDriveRepo(db),
 		Charges: chargingdb.NewChargingRepo(db),
 	})
-	aiChatbotHandler := NewAIChatbotHandler(
+	aiChatbotHandler := aichatbot.NewHandler(
 		dbnotif.NewChatRepo(db),
 		aiRegistry,
 		aiToolRegistry,