1{
2  "summary": "用户咨询退款到账时间，客服告知预计 3-5 个工作日",
3  "category": "refund",
4  "risk_level": "low",
5  "next_action": "等待退款到账"
6}

1{
2  "model": "deepseek-v4-flash",
3  "thinking": {"type": "disabled"}
4}

1{
2  "model": "deepseek-v4-flash",
3  "thinking": {"type": "disabled"}
4}

1{
2  "model": "deepseek-v4-flash",
3  "thinking": {
4    "type": "enabled",
5    "reasoning_effort": "high"
6  }
7}

 1{
 2  "model": "deepseek-v4-flash",
 3  "thinking": {"type": "disabled"},
 4  "temperature": 0.2,
 5  "messages": [
 6    {
 7      "role": "system",
 8      "content": "你是客服工单分析助手，只输出 JSON。"
 9    },
10    {
11      "role": "user",
12      "content": "请总结这段客服对话，并判断 category、risk_level、next_action。..."
13    }
14  ]
15}

1{
2  "top_k": 40
3}

1{
2  "summary": "用户咨询退款到账时间，客服说明

1```json
2{...}

1{
2  "response_format": {"type": "json_object"}
3}

1{
2  "response_format": {"type": "json_object"},
3  "messages": [
4    {
5      "role": "system",
6      "content": "你是客服工单分析助手。只输出 JSON，不要输出 Markdown，不要解释。字段必须包含 summary、category、risk_level、next_action。"
7    }
8  ]
9}

 1type TicketSummary struct {
 2	Summary    string `json:"summary"`
 3	Category   string `json:"category"`
 4	RiskLevel  string `json:"risk_level"`
 5	NextAction string `json:"next_action"`
 6}
 7
 8func validateSummary(s TicketSummary) error {
 9	if s.Summary == "" || s.Category == "" || s.RiskLevel == "" {
10		return fmt.Errorf("missing required fields")
11	}
12
13	allowedRisk := map[string]bool{
14		"low": true, "medium": true, "high": true,
15	}
16	if !allowedRisk[s.RiskLevel] {
17		return fmt.Errorf("invalid risk_level: %s", s.RiskLevel)
18	}
19
20	return nil
21}

 1{
 2  "tools": [
 3    {
 4      "type": "function",
 5      "function": {
 6        "name": "escalate_ticket",
 7        "description": "将高风险客服工单升级给人工主管",
 8        "parameters": {
 9          "type": "object",
10          "properties": {
11            "ticket_id": {"type": "string"},
12            "risk_level": {"type": "string", "enum": ["medium", "high"]},
13            "reason": {"type": "string"}
14          },
15          "required": ["ticket_id", "risk_level", "reason"]
16        },
17        "strict": true
18      }
19    }
20  ],
21  "tool_choice": "auto"
22}

1{
2  "stop": ["<END_OF_TICKET_SUMMARY>"]
3}

 1model
 2thinking.type
 3temperature
 4max_tokens
 5finish_reason
 6prompt_tokens
 7completion_tokens
 8reasoning_tokens
 9prompt_cache_hit_tokens
10prompt_cache_miss_tokens
11latency_ms
12json_parse_ok
13validation_ok

1{
2  "category": "refund",
3  "risk_level": "low"
4}

1{
2  "user_id": "tenant_42_user_8f3a9c"
3}

1{
2  "user_id": "13800138000"
3}

1{
2  "temperature": 0.2,
3  "top_p": 1,
4  "seed": 42,
5  "n": 3,
6  "parallel_tool_calls": true,
7  "store": true,
8  "metadata": {"scene": "ticket_summary"}
9}

  1package main
  2
  3import (
  4	"bytes"
  5	"context"
  6	"encoding/json"
  7	"fmt"
  8	"io"
  9	"net/http"
 10	"os"
 11	"time"
 12)
 13
 14const deepseekAPI = "https://api.deepseek.com/chat/completions"
 15
 16type Message struct {
 17	Role    string `json:"role"`
 18	Content string `json:"content"`
 19}
 20
 21type Thinking struct {
 22	Type            string `json:"type"`                       // "enabled" 或 "disabled"
 23	ReasoningEffort string `json:"reasoning_effort,omitempty"` // "high" 或 "max"
 24}
 25
 26type ResponseFormat struct {
 27	Type string `json:"type"` // "text" 或 "json_object"
 28}
 29
 30type ChatRequest struct {
 31	Model          string          `json:"model"`
 32	Messages       []Message       `json:"messages"`
 33	Thinking       *Thinking       `json:"thinking,omitempty"`
 34	MaxTokens      int             `json:"max_tokens,omitempty"`
 35	Temperature    *float64        `json:"temperature,omitempty"`
 36	TopP           *float64        `json:"top_p,omitempty"`
 37	ResponseFormat *ResponseFormat `json:"response_format,omitempty"`
 38	Stop           []string        `json:"stop,omitempty"`
 39	Stream         bool            `json:"stream,omitempty"`
 40	Logprobs       bool            `json:"logprobs,omitempty"`
 41	TopLogprobs    int             `json:"top_logprobs,omitempty"`
 42	UserID         string          `json:"user_id,omitempty"`
 43}
 44
 45type ChatResponse struct {
 46	Choices []struct {
 47		Message struct {
 48			Content          string `json:"content"`
 49			ReasoningContent string `json:"reasoning_content"`
 50		} `json:"message"`
 51		FinishReason string `json:"finish_reason"`
 52	} `json:"choices"`
 53	Usage struct {
 54		PromptTokens          int `json:"prompt_tokens"`
 55		CompletionTokens      int `json:"completion_tokens"`
 56		TotalTokens           int `json:"total_tokens"`
 57		PromptCacheHitTokens  int `json:"prompt_cache_hit_tokens"`
 58		PromptCacheMissTokens int `json:"prompt_cache_miss_tokens"`
 59		CompletionDetails     struct {
 60			ReasoningTokens int `json:"reasoning_tokens"`
 61		} `json:"completion_tokens_details"`
 62	} `json:"usage"`
 63}
 64
 65type TicketSummary struct {
 66	Summary    string `json:"summary"`
 67	Category   string `json:"category"`
 68	RiskLevel  string `json:"risk_level"`
 69	NextAction string `json:"next_action"`
 70}
 71
 72func float64Ptr(v float64) *float64 { return &v }
 73
 74func callDeepSeek(ctx context.Context, req ChatRequest) (*ChatResponse, error) {
 75	apiKey := os.Getenv("DEEPSEEK_API_KEY")
 76	if apiKey == "" {
 77		return nil, fmt.Errorf("DEEPSEEK_API_KEY is empty")
 78	}
 79
 80	body, err := json.Marshal(req)
 81	if err != nil {
 82		return nil, fmt.Errorf("marshal request: %w", err)
 83	}
 84
 85	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, deepseekAPI, bytes.NewReader(body))
 86	if err != nil {
 87		return nil, err
 88	}
 89	httpReq.Header.Set("Content-Type", "application/json")
 90	httpReq.Header.Set("Authorization", "Bearer "+apiKey)
 91
 92	client := &http.Client{Timeout: 60 * time.Second}
 93	resp, err := client.Do(httpReq)
 94	if err != nil {
 95		return nil, fmt.Errorf("call deepseek: %w", err)
 96	}
 97	defer resp.Body.Close()
 98
 99	if resp.StatusCode != http.StatusOK {
100		b, _ := io.ReadAll(resp.Body)
101		return nil, fmt.Errorf("deepseek api status=%d body=%s", resp.StatusCode, string(b))
102	}
103
104	var result ChatResponse
105	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
106		return nil, fmt.Errorf("decode response: %w", err)
107	}
108	if len(result.Choices) == 0 {
109		return nil, fmt.Errorf("empty choices")
110	}
111
112	return &result, nil
113}
114
115func validateSummary(s TicketSummary) error {
116	if s.Summary == "" || s.Category == "" || s.RiskLevel == "" || s.NextAction == "" {
117		return fmt.Errorf("missing required field: %+v", s)
118	}
119
120	allowedRisk := map[string]bool{
121		"low": true, "medium": true, "high": true,
122	}
123	if !allowedRisk[s.RiskLevel] {
124		return fmt.Errorf("invalid risk_level: %s", s.RiskLevel)
125	}
126
127	return nil
128}
129
130func summarizeTicket(ctx context.Context, dialogue string) (TicketSummary, error) {
131	req := ChatRequest{
132		Model:       "deepseek-v4-flash",
133		Thinking:    &Thinking{Type: "disabled"},
134		Temperature: float64Ptr(0.2),
135		MaxTokens:   512,
136		UserID:      "tenant_demo_user_demo",
137		ResponseFormat: &ResponseFormat{
138			Type: "json_object",
139		},
140		Messages: []Message{
141			{
142				Role: "system",
143				Content: `你是客服工单分析助手。只输出 JSON，不要输出 Markdown，不要解释。
144字段必须包含：
145- summary: 一句话总结用户问题和客服答复
146- category: refund/payment/account/logistics/other 之一
147- risk_level: low/medium/high 之一
148- next_action: 下一步处理动作`,
149			},
150			{
151				Role:    "user",
152				Content: "请分析这段客服对话：\n" + dialogue,
153			},
154		},
155	}
156
157	resp, err := callDeepSeek(ctx, req)
158	if err != nil {
159		return TicketSummary{}, err
160	}
161
162	choice := resp.Choices[0]
163	if choice.FinishReason == "length" {
164		return TicketSummary{}, fmt.Errorf("model output truncated by max_tokens")
165	}
166	if choice.FinishReason != "stop" {
167		return TicketSummary{}, fmt.Errorf("unexpected finish_reason: %s", choice.FinishReason)
168	}
169
170	var summary TicketSummary
171	if err := json.Unmarshal([]byte(choice.Message.Content), &summary); err != nil {
172		return TicketSummary{}, fmt.Errorf("invalid json output: %w, raw=%s", err, choice.Message.Content)
173	}
174	if err := validateSummary(summary); err != nil {
175		return TicketSummary{}, err
176	}
177
178	fmt.Printf(
179		"usage prompt=%d completion=%d total=%d cache_hit=%d cache_miss=%d reasoning=%d\n",
180		resp.Usage.PromptTokens,
181		resp.Usage.CompletionTokens,
182		resp.Usage.TotalTokens,
183		resp.Usage.PromptCacheHitTokens,
184		resp.Usage.PromptCacheMissTokens,
185		resp.Usage.CompletionDetails.ReasoningTokens,
186	)
187
188	return summary, nil
189}
190
191func main() {
192	ctx := context.Background()
193	dialogue := `用户：我上周申请退款了，怎么还没到账？
194客服：您好，退款一般 3-5 个工作日到账。您这笔订单是周五提交的，预计本周三前到账。
195用户：那我再等等。`
196
197	summary, err := summarizeTicket(ctx, dialogue)
198	if err != nil {
199		fmt.Println("error:", err)
200		return
201	}
202	fmt.Printf("%+v\n", summary)
203}