digital-psychology/apps/api/internal/llm/deepseek/client.go

// Package deepseek calls DeepSeek OpenAI-compatible Chat Completions API.
package deepseek

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"

	"github.com/yuxingu/digital-psychology/apps/api/internal/config"
)

// Message is one chat turn.
type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

// Client talks to DeepSeek.
type Client struct {
	cfg    config.DeepSeekConfig
	http   *http.Client
}

// New builds a client from config.
func New(cfg config.DeepSeekConfig) *Client {
	sec := cfg.TimeoutSec
	if sec <= 0 {
		sec = 60
	}
	return &Client{
		cfg: cfg,
		http: &http.Client{
			Timeout: time.Duration(sec) * time.Second,
		},
	}
}

// Enabled mirrors config.
func (c *Client) Enabled() bool {
	return c != nil && c.cfg.Enabled()
}

type chatRequest struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
	Stream   bool      `json:"stream"`
}

type chatResponse struct {
	Choices []struct {
		Message Message `json:"message"`
	} `json:"choices"`
	Error *struct {
		Message string `json:"message"`
	} `json:"error"`
}

// Chat sends messages and returns assistant text.
func (c *Client) Chat(ctx context.Context, messages []Message) (string, error) {
	if !c.Enabled() {
		return "", fmt.Errorf("deepseek api_key not configured")
	}
	base := c.cfg.BaseURL
	if base == "" {
		base = "https://api.deepseek.com"
	}
	model := c.cfg.Model
	if model == "" {
		model = "deepseek-chat"
	}

	body, err := json.Marshal(chatRequest{Model: model, Messages: messages, Stream: false})
	if err != nil {
		return "", err
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, base+"/chat/completions", bytes.NewReader(body))
	if err != nil {
		return "", err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+c.cfg.APIKey)

	res, err := c.http.Do(req)
	if err != nil {
		return "", err
	}
	defer res.Body.Close()
	raw, err := io.ReadAll(io.LimitReader(res.Body, 2<<20))
	if err != nil {
		return "", err
	}
	var out chatResponse
	if err := json.Unmarshal(raw, &out); err != nil {
		return "", fmt.Errorf("deepseek decode: %w body=%s", err, truncate(string(raw), 200))
	}
	if out.Error != nil && out.Error.Message != "" {
		return "", fmt.Errorf("deepseek: %s", out.Error.Message)
	}
	if res.StatusCode >= 300 {
		return "", fmt.Errorf("deepseek HTTP %d: %s", res.StatusCode, truncate(string(raw), 200))
	}
	if len(out.Choices) == 0 || strings.TrimSpace(out.Choices[0].Message.Content) == "" {
		return "", fmt.Errorf("deepseek empty choices")
	}
	return strings.TrimSpace(out.Choices[0].Message.Content), nil
}

func truncate(s string, n int) string {
	if len(s) <= n {
		return s
	}
	return s[:n] + "…"
}