Week 4 Day 26：Failure Mode Review - 苏格拉底教学#

// internal/eval/hallucination_detector.go
package eval

import "strings"

type HallucinationSignal struct {
	Query       string
	LLMResponse string
	Sources     []string // RAG 检索到的原文
}

// DetectSourceless 检查 LLM 的回答是否有 source 支撑
// 简单版：response 中的关键事实能否在 sources 中找到
func DetectSourceless(signal HallucinationSignal) bool {
	if len(signal.Sources) == 0 {
		// 没有任何 source 支撑，高风险
		return true
	}

	// 检查回答中的数字（通常是最容易被幻觉的）
	// 更完整的实现应该用 LLM 自身来判断
	sourcesContent := strings.Join(signal.Sources, " ")
	_ = sourcesContent

	// TODO: 接入 LLM-as-judge 评估
	return false
}

// internal/tools/timeout_wrapper.go
package tools

import (
	"context"
	"fmt"
	"time"
)

type TimeoutConfig struct {
	Default  time.Duration
	PerTool  map[string]time.Duration
}

func DefaultTimeoutConfig() TimeoutConfig {
	return TimeoutConfig{
		Default: 5 * time.Second,
		PerTool: map[string]time.Duration{
			"search_kb":       3 * time.Second,
			"create_ticket":   10 * time.Second, // 写操作给多点时间
			"get_user_info":   2 * time.Second,
			"send_slack":      5 * time.Second,
		},
	}
}

func WithToolTimeout(cfg TimeoutConfig, toolName string, fn func(ctx context.Context) (any, error)) func(ctx context.Context) (any, error) {
	timeout := cfg.Default
	if t, ok := cfg.PerTool[toolName]; ok {
		timeout = t
	}

	return func(ctx context.Context) (any, error) {
		ctx, cancel := context.WithTimeout(ctx, timeout)
		defer cancel()

		resultCh := make(chan struct {
			result any
			err    error
		}, 1)

		go func() {
			result, err := fn(ctx)
			resultCh <- struct {
				result any
				err    error
			}{result, err}
		}()

		select {
		case r := <-resultCh:
			return r.result, r.err
		case <-ctx.Done():
			return nil, fmt.Errorf("tool %s timeout after %v: %w", toolName, timeout, ctx.Err())
		}
	}
}

// internal/security/injection_detector.go
package security

import (
	"strings"
	"unicode"
)

var injectionPatterns = []string{
	"ignore previous",
	"忽略之前",
	"disregard your instructions",
	"you are now",
	"forget everything",
	"reveal your system prompt",
	"show me your instructions",
	"act as",
	"pretend you are",
}

type InjectionResult struct {
	Detected bool
	Pattern  string
	Risk     string // "high" | "medium" | "low"
}

func DetectInjection(userInput string) InjectionResult {
	normalized := strings.ToLower(strings.Map(func(r rune) rune {
		if unicode.IsPunct(r) {
			return ' '
		}
		return r
	}, userInput))

	for _, pattern := range injectionPatterns {
		if strings.Contains(normalized, pattern) {
			return InjectionResult{
				Detected: true,
				Pattern:  pattern,
				Risk:     "high",
			}
		}
	}
	return InjectionResult{Detected: false}
}

// internal/security/pii_detector.go
package security

import "regexp"

var piiPatterns = map[string]*regexp.Regexp{
	"email":       regexp.MustCompile(`[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}`),
	"phone_cn":    regexp.MustCompile(`1[3-9]\d{9}`),
	"id_card_cn":  regexp.MustCompile(`\d{17}[\dX]`),
	"credit_card": regexp.MustCompile(`\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}`),
}

type PIIDetectionResult struct {
	HasPII   bool
	Types    []string // 检测到的 PII 类型
	Redacted string   // 脱敏后的文本
}

func DetectAndRedactPII(text string) PIIDetectionResult {
	result := PIIDetectionResult{Redacted: text}

	for piiType, pattern := range piiPatterns {
		if pattern.MatchString(text) {
			result.HasPII = true
			result.Types = append(result.Types, piiType)
			result.Redacted = pattern.ReplaceAllString(result.Redacted, "[REDACTED]")
		}
	}

	return result
}

// internal/tools/idempotency.go
package tools

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"time"
)

type IdempotencyKey struct {
	UserID    string
	Action    string
	Params    string // params 的 JSON 序列化
	Timestamp time.Time
}

// GenerateKey 生成幂等键（5分钟窗口内相同操作视为重复）
func GenerateKey(k IdempotencyKey) string {
	// 截断到5分钟，同一5分钟窗口内的相同操作视为重复
	window := k.Timestamp.Truncate(5 * time.Minute).Unix()

	raw := fmt.Sprintf("%s|%s|%s|%d", k.UserID, k.Action, k.Params, window)
	h := sha256.Sum256([]byte(raw))
	return hex.EncodeToString(h[:])[:24]
}

type IdempotentToolExecutor struct {
	store  IdempotencyStore
	window time.Duration
}

type IdempotencyStore interface {
	// SetIfNotExists 原子操作：如果 key 不存在则 set，返回是否成功 set
	SetIfNotExists(ctx context.Context, key string, value []byte, ttl time.Duration) (bool, error)
	Get(ctx context.Context, key string) ([]byte, error)
}

func (e *IdempotentToolExecutor) Execute(
	ctx context.Context,
	key string,
	fn func(ctx context.Context) (any, error),
) (any, bool, error) {
	// 1. 检查 key 是否已存在
	existing, err := e.store.Get(ctx, key)
	if err == nil && existing != nil {
		// 已经执行过，直接返回之前的结果
		return existing, true, nil // true = was deduplicated
	}

	// 2. 执行实际操作
	result, err := fn(ctx)
	if err != nil {
		return nil, false, err
	}

	// 3. 存储结果，防止后续重复
	_ = e.store.SetIfNotExists(ctx, key, []byte(fmt.Sprintf("%v", result)), e.window)

	return result, false, nil
}

// internal/chaos/fault_injector.go
package chaos

import (
	"context"
	"errors"
	"math/rand"
	"time"
)

// FaultConfig 故障注入配置
type FaultConfig struct {
	Enabled         bool
	LatencyRate     float64       // 多少比例的请求注入延迟
	LatencyDuration time.Duration // 注入的延迟量
	ErrorRate       float64       // 多少比例的请求返回错误
}

type FaultInjector struct {
	config FaultConfig
	rng    *rand.Rand
}

func NewFaultInjector(cfg FaultConfig) *FaultInjector {
	return &FaultInjector{
		config: cfg,
		rng:    rand.New(rand.NewSource(time.Now().UnixNano())),
	}
}

// WrapTool 在 tool 调用外层注入故障
func (fi *FaultInjector) WrapTool(toolName string, fn func(ctx context.Context) (any, error)) func(ctx context.Context) (any, error) {
	if !fi.config.Enabled {
		return fn
	}

	return func(ctx context.Context) (any, error) {
		// 注入延迟
		if fi.rng.Float64() < fi.config.LatencyRate {
			select {
			case <-time.After(fi.config.LatencyDuration):
			case <-ctx.Done():
				return nil, ctx.Err()
			}
		}

		// 注入错误
		if fi.rng.Float64() < fi.config.ErrorRate {
			return nil, errors.New("chaos: injected fault for tool " + toolName)
		}

		return fn(ctx)
	}
}

// 0/1 背包标准解法
// n 个 chunk，token 预算 capacity
// 选出 token 总量不超过 capacity 且相关性分数最高的 chunk 组合
func knapsack(scores []float64, tokens []int, capacity int) (float64, []int) {
	n := len(scores)
	// dp[i][j] = 前 i 个 chunk，token 预算 j 时的最大分数
	dp := make([][]float64, n+1)
	for i := range dp {
		dp[i] = make([]float64, capacity+1)
	}

	for i := 1; i <= n; i++ {
		for j := 0; j <= capacity; j++ {
			// 不选第 i 个
			dp[i][j] = dp[i-1][j]
			// 选第 i 个（如果装得下）
			if tokens[i-1] <= j {
				withItem := dp[i-1][j-tokens[i-1]] + scores[i-1]
				if withItem > dp[i][j] {
					dp[i][j] = withItem
				}
			}
		}
	}

	// 回溯选中的 chunk
	selected := []int{}
	j := capacity
	for i := n; i >= 1; i-- {
		if dp[i][j] != dp[i-1][j] {
			selected = append(selected, i-1)
			j -= tokens[i-1]
		}
	}
	return dp[n][capacity], selected
}

import "container/heap"

type Item struct {
	node, dist int
	index      int
}
type PriorityQueue []*Item

func (pq PriorityQueue) Len() int            { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool  { return pq[i].dist < pq[j].dist }
func (pq PriorityQueue) Swap(i, j int)       { pq[i], pq[j] = pq[j], pq[i]; pq[i].index = i; pq[j].index = j }
func (pq *PriorityQueue) Push(x any)         { *pq = append(*pq, x.(*Item)) }
func (pq *PriorityQueue) Pop() any           { old := *pq; n := len(old); x := old[n-1]; *pq = old[:n-1]; return x }

func dijkstra(n int, graph [][][2]int, src int) []int {
	dist := make([]int, n)
	for i := range dist {
		dist[i] = 1<<31 - 1
	}
	dist[src] = 0

	pq := &PriorityQueue{{node: src, dist: 0}}
	heap.Init(pq)

	for pq.Len() > 0 {
		curr := heap.Pop(pq).(*Item)
		if curr.dist > dist[curr.node] {
			continue
		}
		for _, edge := range graph[curr.node] {
			neighbor, weight := edge[0], edge[1]
			if newDist := dist[curr.node] + weight; newDist < dist[neighbor] {
				dist[neighbor] = newDist
				heap.Push(pq, &Item{node: neighbor, dist: newDist})
			}
		}
	}
	return dist
}