story/internal/extraction/generator.go

package extraction

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

	"data-terminal-cloud/internal/contentpolicy"
	"data-terminal-cloud/internal/outbox"
)

type GenerationInput struct {
	TenantID string
	Content  string
}

type GenerationResult struct {
	Summary       string   `json:"summary"`
	OpenTopic     string   `json:"open_topic"`
	StoryTitle    string   `json:"story_title"`
	StoryContent  string   `json:"story_content"`
	FactContent   string   `json:"fact_content"`
	Keywords      []string `json:"keywords"`
	Confidence    float64  `json:"confidence"`
	ModelRef      string   `json:"-"`
	PromptVersion string   `json:"-"`
	AllowStory    bool     `json:"-"`
}

type Generator interface {
	Generate(context.Context, GenerationInput) (GenerationResult, error)
}

type DeterministicGenerator struct{}

func (DeterministicGenerator) Generate(_ context.Context, input GenerationInput) (GenerationResult, error) {
	content := strings.TrimSpace(input.Content)
	if content == "" {
		return GenerationResult{}, errors.New("extraction content is required")
	}
	return GenerationResult{
		Summary:       "长者在本次通话中谈到：" + content,
		OpenTopic:     "下次可以继续询问长者刚才提到的经历，并让长者自行补充人物、时间和地点。",
		StoryTitle:    "关于“" + truncateRunes(content, 24) + "”的回忆",
		StoryContent:  content,
		FactContent:   content,
		Keywords:      deterministicKeywords(content),
		Confidence:    0.9,
		ModelRef:      "local-deterministic-extractor",
		PromptVersion: "story-v1",
		AllowStory:    true,
	}, nil
}

func sensitiveGeneration(decision contentpolicy.Decision) GenerationResult {
	modelRef := strings.TrimSpace(decision.ProviderRef)
	if modelRef == "" {
		modelRef = "local-content-safety-policy"
	}
	reason := safePolicyToken(decision.Reason)
	return GenerationResult{
		Summary:       "本次通话包含需要人工谨慎处理的敏感信息，系统未生成普通故事卡片。",
		OpenTopic:     "如确有必要处理本次敏感内容，应由有权限人员在受控流程中单独核对。",
		Confidence:    1,
		ModelRef:      modelRef,
		PromptVersion: "summary-sensitive-filter-v1:" + reason,
		AllowStory:    false,
	}
}

func safePolicyToken(value string) string {
	value = strings.ToLower(strings.TrimSpace(value))
	if value == "" || len(value) > 64 {
		return "policy_block"
	}
	for _, character := range value {
		if (character < 'a' || character > 'z') && (character < '0' || character > '9') && character != '_' && character != '-' {
			return "policy_block"
		}
	}
	return value
}

type ArkGenerator struct {
	endpoint    string
	apiKey      string
	model       string
	provider    string
	temperature float64
	maxTokens   int
	client      *http.Client
}

func NewArkGenerator(baseURL, apiKey, model string, timeout time.Duration) (*ArkGenerator, error) {
	return NewCompatibleGenerator("ark", baseURL, apiKey, model, 0.2, 1200, timeout)
}

func NewCompatibleGenerator(provider, baseURL, apiKey, model string, temperature float64, maxTokens int, timeout time.Duration) (*ArkGenerator, error) {
	provider = strings.ToLower(strings.TrimSpace(provider))
	baseURL = strings.TrimRight(strings.TrimSpace(baseURL), "/")
	apiKey = strings.TrimSpace(apiKey)
	model = strings.TrimSpace(model)
	parsed, err := url.Parse(baseURL)
	if err != nil || parsed.Host == "" || (parsed.Scheme != "http" && parsed.Scheme != "https") {
		return nil, errors.New("Ark base URL must be an absolute HTTP(S) URL")
	}
	if provider != "ark" && provider != "openai_compatible" {
		return nil, errors.New("content model provider must be ark or openai_compatible")
	}
	if apiKey == "" || model == "" || timeout <= 0 || temperature < 0 || temperature > 2 || maxTokens < 256 || maxTokens > 8192 {
		return nil, errors.New("content model credentials and valid generation parameters are required")
	}
	return &ArkGenerator{
		endpoint: baseURL + "/chat/completions", apiKey: apiKey, model: model,
		provider: provider, temperature: temperature, maxTokens: maxTokens,
		client: &http.Client{Timeout: timeout},
	}, nil
}

func (g *ArkGenerator) Generate(ctx context.Context, input GenerationInput) (GenerationResult, error) {
	content := strings.TrimSpace(input.Content)
	if content == "" {
		return GenerationResult{}, errors.New("extraction content is required")
	}
	requestBody := map[string]any{
		"model": g.model,
		"messages": []map[string]string{
			{"role": "system", "content": "你是长者口述内容整理助手。只依据输入字幕生成可人工核对的候选，不补充未出现的事实，不把推断写成事实。必须返回JSON对象，字段为summary、keywords、open_topic、story_title、story_content、fact_content、confidence。summary概括本次内容，keywords是1至8个简短关键词字符串组成的数组，open_topic给出一个温和的后续话题，story和fact保留原意，confidence取0到1。"},
			{"role": "user", "content": content},
		},
		"temperature":     g.temperature,
		"max_tokens":      g.maxTokens,
		"response_format": map[string]string{"type": "json_object"},
	}
	encoded, err := json.Marshal(requestBody)
	if err != nil {
		return GenerationResult{}, err
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodPost, g.endpoint, bytes.NewReader(encoded))
	if err != nil {
		return GenerationResult{}, fmt.Errorf("build Ark content request: %w", err)
	}
	req.Header.Set("Authorization", "Bearer "+g.apiKey)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("User-Agent", "voice-platform-content-extractor/1.0")
	resp, err := g.client.Do(req)
	if err != nil {
		return GenerationResult{}, outbox.Retryable(fmt.Errorf("call Ark content model: %w", err))
	}
	defer resp.Body.Close()
	responseBody, readErr := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
	if readErr != nil {
		return GenerationResult{}, outbox.Retryable(fmt.Errorf("read Ark content response: %w", readErr))
	}
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		requestErr := fmt.Errorf("Ark content model returned HTTP %d", resp.StatusCode)
		if resp.StatusCode == http.StatusRequestTimeout || resp.StatusCode == http.StatusTooEarly || resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode >= 500 {
			return GenerationResult{}, outbox.Retryable(requestErr)
		}
		return GenerationResult{}, requestErr
	}
	var completion struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
	}
	if err = json.Unmarshal(responseBody, &completion); err != nil || len(completion.Choices) == 0 {
		return GenerationResult{}, outbox.Retryable(errors.New("Ark content response has no usable choice"))
	}
	jsonContent := strings.TrimSpace(completion.Choices[0].Message.Content)
	jsonContent = strings.TrimPrefix(jsonContent, "```json")
	jsonContent = strings.TrimPrefix(jsonContent, "```")
	jsonContent = strings.TrimSuffix(jsonContent, "```")
	var result GenerationResult
	if err = json.Unmarshal([]byte(strings.TrimSpace(jsonContent)), &result); err != nil {
		return GenerationResult{}, outbox.Retryable(fmt.Errorf("decode Ark structured content: %w", err))
	}
	result.Summary = strings.TrimSpace(result.Summary)
	result.OpenTopic = strings.TrimSpace(result.OpenTopic)
	result.StoryTitle = strings.TrimSpace(result.StoryTitle)
	result.StoryContent = strings.TrimSpace(result.StoryContent)
	result.FactContent = strings.TrimSpace(result.FactContent)
	result.Keywords = normalizedKeywords(result.Keywords)
	if !validGeneratedContent(result) {
		return GenerationResult{}, outbox.Retryable(errors.New("Ark structured content failed validation"))
	}
	result.ModelRef = g.provider + ":" + g.model
	result.PromptVersion = "story-" + g.provider + "-json-v2"
	result.AllowStory = true
	return result, nil
}

func validGeneratedContent(result GenerationResult) bool {
	return result.Summary != "" && len([]rune(result.Summary)) <= 2000 &&
		result.OpenTopic != "" && len([]rune(result.OpenTopic)) <= 1000 &&
		result.StoryTitle != "" && len([]rune(result.StoryTitle)) <= 300 &&
		result.StoryContent != "" && len([]rune(result.StoryContent)) <= 20000 &&
		result.FactContent != "" && len([]rune(result.FactContent)) <= 5000 &&
		len(result.Keywords) >= 1 && len(result.Keywords) <= 8 &&
		result.Confidence >= 0 && result.Confidence <= 1
}

func normalizedKeywords(values []string) []string {
	result := make([]string, 0, min(len(values), 8))
	seen := make(map[string]struct{}, len(values))
	for _, value := range values {
		value = strings.TrimSpace(value)
		if value == "" || len([]rune(value)) > 40 {
			continue
		}
		if _, exists := seen[value]; exists {
			continue
		}
		seen[value] = struct{}{}
		result = append(result, value)
		if len(result) == 8 {
			break
		}
	}
	return result
}

func deterministicKeywords(content string) []string {
	parts := strings.FieldsFunc(content, func(character rune) bool {
		return unicode.IsSpace(character) || strings.ContainsRune("，。！？；、,.!?;：:\"“”‘’（）()", character)
	})
	candidates := make([]string, 0, len(parts))
	for _, part := range parts {
		runes := []rune(strings.TrimSpace(part))
		if len(runes) < 2 {
			continue
		}
		if len(runes) > 12 {
			runes = runes[:12]
		}
		candidates = append(candidates, string(runes))
	}
	keywords := normalizedKeywords(candidates)
	if len(keywords) > 0 {
		return keywords
	}
	runes := []rune(content)
	if len(runes) > 12 {
		runes = runes[:12]
	}
	return []string{string(runes)}
}