Completions api (#8) (#29)

2026-02-16 17:00:11 +00:00
parent d83217504c
commit d9ab162dfb
13 changed files with 1885 additions and 113 deletions
--- a/server/handlers/apiconfigs.go
+++ b/server/handlers/apiconfigs.go
@@ -0,0 +1,442 @@
+package handlers
+
+import (
+	"database/sql"
+	"encoding/json"
+	"math"
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"git.gobha.me/xcaliber/chat-switchboard/database"
+	"git.gobha.me/xcaliber/chat-switchboard/providers"
+)
+
+// ── Request / Response Types ────────────────
+
+type createAPIConfigRequest struct {
+	Name         string                 `json:"name" binding:"required,max=100"`
+	Provider     string                 `json:"provider" binding:"required"`
+	Endpoint     string                 `json:"endpoint" binding:"required"`
+	APIKey       string                 `json:"api_key"`
+	ModelDefault string                 `json:"model_default,omitempty"`
+	Config       map[string]interface{} `json:"config,omitempty"`
+}
+
+type updateAPIConfigRequest struct {
+	Name         *string                `json:"name,omitempty"`
+	Endpoint     *string                `json:"endpoint,omitempty"`
+	APIKey       *string                `json:"api_key,omitempty"`
+	ModelDefault *string                `json:"model_default,omitempty"`
+	Config       map[string]interface{} `json:"config,omitempty"`
+	IsActive     *bool                  `json:"is_active,omitempty"`
+}
+
+type apiConfigResponse struct {
+	ID           string                 `json:"id"`
+	UserID       *string                `json:"user_id"`
+	Name         string                 `json:"name"`
+	Provider     string                 `json:"provider"`
+	Endpoint     string                 `json:"endpoint"`
+	HasKey       bool                   `json:"has_key"` // Never expose the actual key
+	ModelDefault *string                `json:"model_default"`
+	Config       map[string]interface{} `json:"config"`
+	IsActive     bool                   `json:"is_active"`
+	CreatedAt    string                 `json:"created_at"`
+	UpdatedAt    string                 `json:"updated_at"`
+}
+
+// APIConfigHandler holds dependencies.
+type APIConfigHandler struct{}
+
+// NewAPIConfigHandler creates a new handler.
+func NewAPIConfigHandler() *APIConfigHandler {
+	return &APIConfigHandler{}
+}
+
+// ── List API Configs ────────────────────────
+
+func (h *APIConfigHandler) ListConfigs(c *gin.Context) {
+	userID := getUserID(c)
+	page, perPage, offset := parsePagination(c)
+
+	// Count: user's configs + global configs
+	var total int
+	err := database.DB.QueryRow(
+		`SELECT COUNT(*) FROM api_configs WHERE user_id = $1 OR user_id IS NULL`,
+		userID,
+	).Scan(&total)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count configs"})
+		return
+	}
+
+	rows, err := database.DB.Query(`
+		SELECT id, user_id, name, provider, endpoint, api_key_encrypted,
+		       model_default, config, is_active, created_at, updated_at
+		FROM api_configs
+		WHERE user_id = $1 OR user_id IS NULL
+		ORDER BY user_id NULLS LAST, name ASC
+		LIMIT $2 OFFSET $3
+	`, userID, perPage, offset)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list configs"})
+		return
+	}
+	defer rows.Close()
+
+	configs := make([]apiConfigResponse, 0)
+	for rows.Next() {
+		cfg, err := scanAPIConfig(rows)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to scan config"})
+			return
+		}
+		configs = append(configs, cfg)
+	}
+
+	c.JSON(http.StatusOK, paginatedResponse{
+		Data:       configs,
+		Page:       page,
+		PerPage:    perPage,
+		Total:      total,
+		TotalPages: int(math.Ceil(float64(total) / float64(perPage))),
+	})
+}
+
+// ── Create API Config ───────────────────────
+
+func (h *APIConfigHandler) CreateConfig(c *gin.Context) {
+	userID := getUserID(c)
+
+	var req createAPIConfigRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Validate provider exists
+	if _, err := providers.Get(req.Provider); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"error":              "unsupported provider: " + req.Provider,
+			"supported_providers": providers.List(),
+		})
+		return
+	}
+
+	configJSON := "{}"
+	if req.Config != nil {
+		b, _ := json.Marshal(req.Config)
+		configJSON = string(b)
+	}
+
+	var cfg apiConfigResponse
+	var apiKeyEnc *string
+	var configRaw string
+
+	err := database.DB.QueryRow(`
+		INSERT INTO api_configs (user_id, name, provider, endpoint, api_key_encrypted, model_default, config)
+		VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)
+		RETURNING id, user_id, name, provider, endpoint, api_key_encrypted,
+		          model_default, config::text, is_active, created_at, updated_at
+	`, userID, req.Name, req.Provider, req.Endpoint, req.APIKey, req.ModelDefault, configJSON,
+	).Scan(
+		&cfg.ID, &cfg.UserID, &cfg.Name, &cfg.Provider, &cfg.Endpoint, &apiKeyEnc,
+		&cfg.ModelDefault, &configRaw, &cfg.IsActive, &cfg.CreatedAt, &cfg.UpdatedAt,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create config"})
+		return
+	}
+
+	cfg.HasKey = apiKeyEnc != nil && *apiKeyEnc != ""
+	cfg.Config = parseJSONBConfig(configRaw)
+
+	c.JSON(http.StatusCreated, cfg)
+}
+
+// ── Get API Config ──────────────────────────
+
+func (h *APIConfigHandler) GetConfig(c *gin.Context) {
+	userID := getUserID(c)
+	configID := c.Param("id")
+
+	row := database.DB.QueryRow(`
+		SELECT id, user_id, name, provider, endpoint, api_key_encrypted,
+		       model_default, config::text, is_active, created_at, updated_at
+		FROM api_configs
+		WHERE id = $1 AND (user_id = $2 OR user_id IS NULL)
+	`, configID, userID)
+
+	var cfg apiConfigResponse
+	var apiKeyEnc *string
+	var configRaw string
+
+	err := row.Scan(
+		&cfg.ID, &cfg.UserID, &cfg.Name, &cfg.Provider, &cfg.Endpoint, &apiKeyEnc,
+		&cfg.ModelDefault, &configRaw, &cfg.IsActive, &cfg.CreatedAt, &cfg.UpdatedAt,
+	)
+	if err == sql.ErrNoRows {
+		c.JSON(http.StatusNotFound, gin.H{"error": "config not found"})
+		return
+	}
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get config"})
+		return
+	}
+
+	cfg.HasKey = apiKeyEnc != nil && *apiKeyEnc != ""
+	cfg.Config = parseJSONBConfig(configRaw)
+
+	c.JSON(http.StatusOK, cfg)
+}
+
+// ── Update API Config ───────────────────────
+
+func (h *APIConfigHandler) UpdateConfig(c *gin.Context) {
+	userID := getUserID(c)
+	configID := c.Param("id")
+
+	var req updateAPIConfigRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Verify ownership (only owner can update, not global)
+	var ownerID *string
+	err := database.DB.QueryRow(`SELECT user_id FROM api_configs WHERE id = $1`, configID).Scan(&ownerID)
+	if err == sql.ErrNoRows {
+		c.JSON(http.StatusNotFound, gin.H{"error": "config not found"})
+		return
+	}
+	if ownerID == nil || *ownerID != userID {
+		c.JSON(http.StatusForbidden, gin.H{"error": "cannot modify global or other user's config"})
+		return
+	}
+
+	// Dynamic update
+	setClauses := []string{}
+	args := []interface{}{}
+	argN := 1
+
+	addClause := func(col string, val interface{}) {
+		setClauses = append(setClauses, col+" = $"+strconv.Itoa(argN))
+		args = append(args, val)
+		argN++
+	}
+
+	if req.Name != nil {
+		addClause("name", *req.Name)
+	}
+	if req.Endpoint != nil {
+		addClause("endpoint", *req.Endpoint)
+	}
+	if req.APIKey != nil {
+		addClause("api_key_encrypted", *req.APIKey)
+	}
+	if req.ModelDefault != nil {
+		addClause("model_default", *req.ModelDefault)
+	}
+	if req.Config != nil {
+		b, _ := json.Marshal(req.Config)
+		addClause("config", string(b))
+	}
+	if req.IsActive != nil {
+		addClause("is_active", *req.IsActive)
+	}
+
+	if len(setClauses) == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "no fields to update"})
+		return
+	}
+
+	query := "UPDATE api_configs SET updated_at = NOW(), "
+	for i, clause := range setClauses {
+		if i > 0 {
+			query += ", "
+		}
+		query += clause
+	}
+	query += " WHERE id = $" + strconv.Itoa(argN)
+	args = append(args, configID)
+
+	_, err = database.DB.Exec(query, args...)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to update config"})
+		return
+	}
+
+	h.GetConfig(c)
+}
+
+// ── Delete API Config ───────────────────────
+
+func (h *APIConfigHandler) DeleteConfig(c *gin.Context) {
+	userID := getUserID(c)
+	configID := c.Param("id")
+
+	// Only allow deleting own configs
+	result, err := database.DB.Exec(
+		`DELETE FROM api_configs WHERE id = $1 AND user_id = $2`,
+		configID, userID,
+	)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete config"})
+		return
+	}
+	rows, _ := result.RowsAffected()
+	if rows == 0 {
+		c.JSON(http.StatusNotFound, gin.H{"error": "config not found or cannot delete global config"})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "config deleted"})
+}
+
+// ── List Models from a Config ───────────────
+
+func (h *APIConfigHandler) ListModels(c *gin.Context) {
+	userID := getUserID(c)
+	configID := c.Param("id")
+
+	// Load config including API key
+	var providerID, endpoint string
+	var apiKey *string
+	err := database.DB.QueryRow(`
+		SELECT provider, endpoint, api_key_encrypted
+		FROM api_configs
+		WHERE id = $1 AND (user_id = $2 OR user_id IS NULL) AND is_active = true
+	`, configID, userID).Scan(&providerID, &endpoint, &apiKey)
+
+	if err == sql.ErrNoRows {
+		c.JSON(http.StatusNotFound, gin.H{"error": "config not found"})
+		return
+	}
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load config"})
+		return
+	}
+
+	provider, err := providers.Get(providerID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	key := ""
+	if apiKey != nil {
+		key = *apiKey
+	}
+
+	models, err := provider.ListModels(c.Request.Context(), providers.ProviderConfig{
+		Endpoint: endpoint,
+		APIKey:   key,
+	})
+	if err != nil {
+		c.JSON(http.StatusBadGateway, gin.H{"error": "failed to fetch models: " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"config_id": configID,
+		"provider":  providerID,
+		"models":    models,
+	})
+}
+
+// ── List All Available Models (aggregate) ───
+
+func (h *APIConfigHandler) ListAllModels(c *gin.Context) {
+	userID := getUserID(c)
+
+	rows, err := database.DB.Query(`
+		SELECT id, name, provider, endpoint, api_key_encrypted
+		FROM api_configs
+		WHERE (user_id = $1 OR user_id IS NULL) AND is_active = true
+	`, userID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list configs"})
+		return
+	}
+	defer rows.Close()
+
+	type modelEntry struct {
+		ID       string `json:"id"`
+		Name     string `json:"name,omitempty"`
+		OwnedBy  string `json:"owned_by,omitempty"`
+		ConfigID string `json:"config_id"`
+		Provider string `json:"provider"`
+	}
+
+	allModels := make([]modelEntry, 0)
+
+	for rows.Next() {
+		var cfgID, name, providerID, endpoint string
+		var apiKey *string
+		if err := rows.Scan(&cfgID, &name, &providerID, &endpoint, &apiKey); err != nil {
+			continue
+		}
+
+		provider, err := providers.Get(providerID)
+		if err != nil {
+			continue
+		}
+
+		key := ""
+		if apiKey != nil {
+			key = *apiKey
+		}
+
+		models, err := provider.ListModels(c.Request.Context(), providers.ProviderConfig{
+			Endpoint: endpoint,
+			APIKey:   key,
+		})
+		if err != nil {
+			continue // Skip configs that fail
+		}
+
+		for _, m := range models {
+			allModels = append(allModels, modelEntry{
+				ID:       m.ID,
+				Name:     m.Name,
+				OwnedBy:  m.OwnedBy,
+				ConfigID: cfgID,
+				Provider: providerID,
+			})
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{"models": allModels})
+}
+
+// ── Helpers ─────────────────────────────────
+
+type scannable interface {
+	Scan(dest ...interface{}) error
+}
+
+func scanAPIConfig(row scannable) (apiConfigResponse, error) {
+	var cfg apiConfigResponse
+	var apiKeyEnc *string
+	var configRaw string
+
+	err := row.Scan(
+		&cfg.ID, &cfg.UserID, &cfg.Name, &cfg.Provider, &cfg.Endpoint, &apiKeyEnc,
+		&cfg.ModelDefault, &configRaw, &cfg.IsActive, &cfg.CreatedAt, &cfg.UpdatedAt,
+	)
+	if err != nil {
+		return cfg, err
+	}
+
+	cfg.HasKey = apiKeyEnc != nil && *apiKeyEnc != ""
+	cfg.Config = parseJSONBConfig(configRaw)
+	return cfg, nil
+}
+
+func parseJSONBConfig(raw string) map[string]interface{} {
+	result := make(map[string]interface{})
+	_ = json.Unmarshal([]byte(raw), &result)
+	return result
+}
--- a/server/handlers/apiconfigs_test.go
+++ b/server/handlers/apiconfigs_test.go
@@ -0,0 +1,131 @@
+package handlers
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+
+	"git.gobha.me/xcaliber/chat-switchboard/providers"
+)
+
+func init() {
+	gin.SetMode(gin.TestMode)
+	providers.Init()
+}
+
+func TestCreateConfigMissingFields(t *testing.T) {
+	h := NewAPIConfigHandler()
+	r := gin.New()
+	r.POST("/api-configs", func(c *gin.Context) {
+		c.Set("user_id", "test-user")
+		h.CreateConfig(c)
+	})
+
+	tests := []struct {
+		name string
+		body string
+	}{
+		{"missing name", `{"provider":"openai","endpoint":"http://x"}`},
+		{"missing provider", `{"name":"Test","endpoint":"http://x"}`},
+		{"missing endpoint", `{"name":"Test","provider":"openai"}`},
+		{"empty body", `{}`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			w := httptest.NewRecorder()
+			req, _ := http.NewRequest("POST", "/api-configs",
+				bytes.NewBufferString(tt.body))
+			req.Header.Set("Content-Type", "application/json")
+			r.ServeHTTP(w, req)
+
+			if w.Code != http.StatusBadRequest {
+				t.Errorf("Expected 400, got %d (body: %s)", w.Code, w.Body.String())
+			}
+		})
+	}
+}
+
+func TestCreateConfigInvalidProvider(t *testing.T) {
+	h := NewAPIConfigHandler()
+	r := gin.New()
+	r.POST("/api-configs", func(c *gin.Context) {
+		c.Set("user_id", "test-user")
+		h.CreateConfig(c)
+	})
+
+	body := `{"name":"Test","provider":"nonexistent","endpoint":"http://x"}`
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("POST", "/api-configs",
+		bytes.NewBufferString(body))
+	req.Header.Set("Content-Type", "application/json")
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected 400 for invalid provider, got %d", w.Code)
+	}
+
+	var resp map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &resp)
+
+	if _, ok := resp["supported_providers"]; !ok {
+		t.Error("Expected supported_providers in error response")
+	}
+}
+
+func TestCompletionHandlerMissingFields(t *testing.T) {
+	h := NewCompletionHandler()
+	r := gin.New()
+	r.POST("/chat/completions", func(c *gin.Context) {
+		c.Set("user_id", "test-user")
+		h.Complete(c)
+	})
+
+	tests := []struct {
+		name string
+		body string
+	}{
+		{"missing chat_id", `{"content":"hello"}`},
+		{"missing content", `{"chat_id":"abc"}`},
+		{"empty body", `{}`},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			w := httptest.NewRecorder()
+			req, _ := http.NewRequest("POST", "/chat/completions",
+				bytes.NewBufferString(tt.body))
+			req.Header.Set("Content-Type", "application/json")
+			r.ServeHTTP(w, req)
+
+			if w.Code != http.StatusBadRequest {
+				t.Errorf("Expected 400, got %d (body: %s)", w.Code, w.Body.String())
+			}
+		})
+	}
+}
+
+func TestSupportedProviders(t *testing.T) {
+	ids := providers.List()
+
+	expected := map[string]bool{
+		"openai":    false,
+		"anthropic": false,
+	}
+
+	for _, id := range ids {
+		if _, ok := expected[id]; ok {
+			expected[id] = true
+		}
+	}
+
+	for name, found := range expected {
+		if !found {
+			t.Errorf("Expected provider %s to be registered", name)
+		}
+	}
+}
--- a/server/handlers/completion.go
+++ b/server/handlers/completion.go
@@ -0,0 +1,361 @@
+package handlers
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"git.gobha.me/xcaliber/chat-switchboard/database"
+	"git.gobha.me/xcaliber/chat-switchboard/providers"
+)
+
+// ── Request Types ───────────────────────────
+
+type completionRequest struct {
+	ChatID      string   `json:"chat_id" binding:"required"`
+	Content     string   `json:"content" binding:"required"`
+	Model       string   `json:"model,omitempty"`
+	APIConfigID string   `json:"api_config_id,omitempty"`
+	MaxTokens   int      `json:"max_tokens,omitempty"`
+	Temperature *float64 `json:"temperature,omitempty"`
+	TopP        *float64 `json:"top_p,omitempty"`
+	Stream      *bool    `json:"stream,omitempty"`
+}
+
+// CompletionHandler proxies LLM requests through the backend.
+type CompletionHandler struct{}
+
+// NewCompletionHandler creates a new handler.
+func NewCompletionHandler() *CompletionHandler {
+	return &CompletionHandler{}
+}
+
+// ── Chat Completion ─────────────────────────
+// POST /api/v1/chat/completions
+//
+// Flow:
+//   1. Validate request, verify chat ownership
+//   2. Resolve api_config (from request, chat, or user default)
+//   3. Load conversation history from chat_messages
+//   4. Persist user message
+//   5. Call provider (stream or non-stream)
+//   6. Stream SSE to client / return JSON
+//   7. Persist assistant message with token counts
+
+func (h *CompletionHandler) Complete(c *gin.Context) {
+	var req completionRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	userID := getUserID(c)
+
+	// Verify chat ownership
+	if !userOwnsChat(c, req.ChatID, userID) {
+		return
+	}
+
+	// Resolve provider config
+	providerCfg, providerID, model, err := h.resolveConfig(userID, req)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	provider, err := providers.Get(providerID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// Load conversation history
+	messages, err := h.loadConversation(req.ChatID)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to load conversation"})
+		return
+	}
+
+	// Add the new user message
+	messages = append(messages, providers.Message{
+		Role:    "user",
+		Content: req.Content,
+	})
+
+	// Persist user message
+	if err := h.persistMessage(req.ChatID, "user", req.Content, "", 0, 0); err != nil {
+		log.Printf("Failed to persist user message: %v", err)
+	}
+
+	// Build provider request
+	provReq := providers.CompletionRequest{
+		Model:    model,
+		Messages: messages,
+	}
+	if req.MaxTokens > 0 {
+		provReq.MaxTokens = req.MaxTokens
+	}
+	if req.Temperature != nil {
+		provReq.Temperature = req.Temperature
+	}
+	if req.TopP != nil {
+		provReq.TopP = req.TopP
+	}
+
+	// Determine streaming
+	stream := true // default
+	if req.Stream != nil {
+		stream = *req.Stream
+	}
+
+	if stream {
+		h.streamCompletion(c, provider, providerCfg, provReq, req.ChatID, model)
+	} else {
+		h.syncCompletion(c, provider, providerCfg, provReq, req.ChatID, model)
+	}
+}
+
+// ── Streaming Completion (SSE) ──────────────
+
+func (h *CompletionHandler) streamCompletion(
+	c *gin.Context,
+	provider providers.Provider,
+	cfg providers.ProviderConfig,
+	req providers.CompletionRequest,
+	chatID, model string,
+) {
+	ch, err := provider.StreamCompletion(c.Request.Context(), cfg, req)
+	if err != nil {
+		c.JSON(http.StatusBadGateway, gin.H{"error": "provider error: " + err.Error()})
+		return
+	}
+
+	// Set SSE headers
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	c.Header("X-Accel-Buffering", "no") // Disable nginx buffering
+
+	c.Status(http.StatusOK)
+
+	var fullContent string
+	flusher, _ := c.Writer.(http.Flusher)
+
+	for event := range ch {
+		if event.Error != nil {
+			fmt.Fprintf(c.Writer, "data: {\"error\":\"%s\"}\n\n", event.Error.Error())
+			if flusher != nil {
+				flusher.Flush()
+			}
+			break
+		}
+
+		if event.Delta != "" {
+			fullContent += event.Delta
+			// OpenAI-compatible SSE format
+			fmt.Fprintf(c.Writer, "data: {\"choices\":[{\"delta\":{\"content\":%q},\"finish_reason\":null}],\"model\":%q}\n\n",
+				event.Delta, model)
+			if flusher != nil {
+				flusher.Flush()
+			}
+		}
+
+		if event.Done {
+			finishReason := event.FinishReason
+			if finishReason == "" {
+				finishReason = "stop"
+			}
+			fmt.Fprintf(c.Writer, "data: {\"choices\":[{\"delta\":{},\"finish_reason\":%q}],\"model\":%q}\n\n",
+				finishReason, model)
+			io.WriteString(c.Writer, "data: [DONE]\n\n")
+			if flusher != nil {
+				flusher.Flush()
+			}
+			break
+		}
+	}
+
+	// Persist assistant response
+	if fullContent != "" {
+		if err := h.persistMessage(chatID, "assistant", fullContent, model, 0, 0); err != nil {
+			log.Printf("Failed to persist assistant message: %v", err)
+		}
+	}
+}
+
+// ── Non-Streaming Completion ────────────────
+
+func (h *CompletionHandler) syncCompletion(
+	c *gin.Context,
+	provider providers.Provider,
+	cfg providers.ProviderConfig,
+	req providers.CompletionRequest,
+	chatID, model string,
+) {
+	resp, err := provider.ChatCompletion(c.Request.Context(), cfg, req)
+	if err != nil {
+		c.JSON(http.StatusBadGateway, gin.H{"error": "provider error: " + err.Error()})
+		return
+	}
+
+	// Persist assistant response
+	if err := h.persistMessage(chatID, "assistant", resp.Content, model, resp.InputTokens, resp.OutputTokens); err != nil {
+		log.Printf("Failed to persist assistant message: %v", err)
+	}
+
+	// Return OpenAI-compatible response
+	c.JSON(http.StatusOK, gin.H{
+		"model": resp.Model,
+		"choices": []gin.H{
+			{
+				"message": gin.H{
+					"role":    "assistant",
+					"content": resp.Content,
+				},
+				"finish_reason": resp.FinishReason,
+			},
+		},
+		"usage": gin.H{
+			"prompt_tokens":     resp.InputTokens,
+			"completion_tokens": resp.OutputTokens,
+			"total_tokens":      resp.InputTokens + resp.OutputTokens,
+		},
+	})
+}
+
+// ── Config Resolution ───────────────────────
+// Priority: request.api_config_id → chat.api_config_id → user's first active config
+
+func (h *CompletionHandler) resolveConfig(userID string, req completionRequest) (providers.ProviderConfig, string, string, error) {
+	var configID string
+
+	// 1. Explicit config from request
+	if req.APIConfigID != "" {
+		configID = req.APIConfigID
+	}
+
+	// 2. Config from chat
+	if configID == "" {
+		var chatConfigID *string
+		err := database.DB.QueryRow(
+			`SELECT api_config_id FROM chats WHERE id = $1`, req.ChatID,
+		).Scan(&chatConfigID)
+		if err == nil && chatConfigID != nil {
+			configID = *chatConfigID
+		}
+	}
+
+	// 3. User's first active config
+	if configID == "" {
+		err := database.DB.QueryRow(`
+			SELECT id FROM api_configs
+			WHERE (user_id = $1 OR user_id IS NULL) AND is_active = true
+			ORDER BY user_id NULLS LAST, created_at ASC
+			LIMIT 1
+		`, userID).Scan(&configID)
+		if err != nil {
+			return providers.ProviderConfig{}, "", "", fmt.Errorf("no API config found — add one at /api-configs")
+		}
+	}
+
+	// Load the config
+	var providerID, endpoint string
+	var apiKey, modelDefault *string
+	err := database.DB.QueryRow(`
+		SELECT provider, endpoint, api_key_encrypted, model_default
+		FROM api_configs
+		WHERE id = $1 AND (user_id = $2 OR user_id IS NULL) AND is_active = true
+	`, configID, userID).Scan(&providerID, &endpoint, &apiKey, &modelDefault)
+
+	if err == sql.ErrNoRows {
+		return providers.ProviderConfig{}, "", "", fmt.Errorf("API config not found or not accessible")
+	}
+	if err != nil {
+		return providers.ProviderConfig{}, "", "", fmt.Errorf("failed to load API config: %w", err)
+	}
+
+	// Resolve model: request > config default
+	model := req.Model
+	if model == "" && modelDefault != nil {
+		model = *modelDefault
+	}
+	if model == "" {
+		return providers.ProviderConfig{}, "", "", fmt.Errorf("no model specified and no default model in config")
+	}
+
+	key := ""
+	if apiKey != nil {
+		key = *apiKey
+	}
+
+	return providers.ProviderConfig{
+		Endpoint: endpoint,
+		APIKey:   key,
+	}, providerID, model, nil
+}
+
+// ── Conversation Loader ─────────────────────
+
+func (h *CompletionHandler) loadConversation(chatID string) ([]providers.Message, error) {
+	// Load system prompt from chat
+	var systemPrompt *string
+	_ = database.DB.QueryRow(
+		`SELECT system_prompt FROM chats WHERE id = $1`, chatID,
+	).Scan(&systemPrompt)
+
+	messages := make([]providers.Message, 0)
+
+	if systemPrompt != nil && *systemPrompt != "" {
+		messages = append(messages, providers.Message{
+			Role:    "system",
+			Content: *systemPrompt,
+		})
+	}
+
+	// Load message history (oldest first)
+	rows, err := database.DB.Query(`
+		SELECT role, content FROM chat_messages
+		WHERE chat_id = $1
+		ORDER BY created_at ASC
+	`, chatID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var msg providers.Message
+		if err := rows.Scan(&msg.Role, &msg.Content); err != nil {
+			return nil, err
+		}
+		messages = append(messages, msg)
+	}
+
+	return messages, nil
+}
+
+// ── Message Persistence ─────────────────────
+
+func (h *CompletionHandler) persistMessage(chatID, role, content, model string, inputTokens, outputTokens int) error {
+	var tokensUsed *int
+	if inputTokens > 0 || outputTokens > 0 {
+		total := inputTokens + outputTokens
+		tokensUsed = &total
+	}
+
+	_, err := database.DB.Exec(`
+		INSERT INTO chat_messages (chat_id, role, content, model, tokens_used)
+		VALUES ($1, $2, $3, NULLIF($4, ''), $5)
+	`, chatID, role, content, model, tokensUsed)
+	if err != nil {
+		return err
+	}
+
+	// Touch chat updated_at
+	_, _ = database.DB.Exec(`UPDATE chats SET updated_at = NOW() WHERE id = $1`, chatID)
+	return nil
+}