mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-19 08:19:22 +08:00
- Store and retrieve cached Claude web search results via Home KV with sliding TTL expiration when Home mode is enabled. - Propagate request context through Claude web search result recording and restoration helpers in execution and token-counting paths. Closes: #6780
222 lines
6.9 KiB
Go
222 lines
6.9 KiB
Go
package cache
|
|
|
|
import (
|
|
"bytes"
|
|
"container/list"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
homekv "github.com/router-for-me/CLIProxyAPI/v8/internal/home"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
const (
|
|
defaultClaudeWebSearchResultTTL = 24 * time.Hour
|
|
defaultClaudeWebSearchResultLimit = 1024
|
|
)
|
|
|
|
type claudeWebSearchResultEntry struct {
|
|
key string
|
|
content []byte
|
|
ttl time.Duration
|
|
expiresAt time.Time
|
|
}
|
|
|
|
var (
|
|
claudeWebSearchResultMu sync.Mutex
|
|
claudeWebSearchResultIndex = make(map[string]*list.Element)
|
|
claudeWebSearchResultOrder = list.New()
|
|
claudeWebSearchResultNow = time.Now
|
|
)
|
|
|
|
type claudeWebSearchResultKVClient interface {
|
|
KVGet(ctx context.Context, key string) ([]byte, bool, error)
|
|
KVSet(ctx context.Context, key string, value []byte, opts homekv.KVSetOptions) (bool, error)
|
|
KVExpire(ctx context.Context, key string, ttl time.Duration) (bool, error)
|
|
}
|
|
|
|
var currentClaudeWebSearchResultKVClient = func() (claudeWebSearchResultKVClient, bool, error) {
|
|
return homekv.CurrentKVClient()
|
|
}
|
|
|
|
func claudeWebSearchResultKey(sessionKey, toolUseID string) (string, bool) {
|
|
sessionKey = strings.TrimSpace(sessionKey)
|
|
toolUseID = strings.TrimSpace(toolUseID)
|
|
if sessionKey == "" || toolUseID == "" {
|
|
return "", false
|
|
}
|
|
sum := sha256.Sum256([]byte(sessionKey + "\x00" + toolUseID))
|
|
return hex.EncodeToString(sum[:]), true
|
|
}
|
|
|
|
func claudeWebSearchResultKVKey(sessionKey, toolUseID string) string {
|
|
key, ok := claudeWebSearchResultKey(sessionKey, toolUseID)
|
|
if !ok {
|
|
return ""
|
|
}
|
|
return "cpa:claude:web-search-result:" + key
|
|
}
|
|
|
|
// CacheClaudeWebSearchResult stores the raw content of one web_search_tool_result
|
|
// block for a session. Memory is bounded by the maximum entry count (limit);
|
|
// least recently used entries are evicted when the entry limit is exceeded.
|
|
func CacheClaudeWebSearchResult(sessionKey, toolUseID string, content []byte, ttl time.Duration, limit int) {
|
|
CacheClaudeWebSearchResultBestEffort(context.Background(), sessionKey, toolUseID, content, ttl, limit)
|
|
}
|
|
|
|
// CacheClaudeWebSearchResultBestEffort stores the raw content of one
|
|
// web_search_tool_result block for completed response paths.
|
|
func CacheClaudeWebSearchResultBestEffort(ctx context.Context, sessionKey, toolUseID string, content []byte, ttl time.Duration, limit int) bool {
|
|
key, ok := claudeWebSearchResultKey(sessionKey, toolUseID)
|
|
if !ok || len(content) == 0 {
|
|
return false
|
|
}
|
|
if ttl <= 0 {
|
|
ttl = defaultClaudeWebSearchResultTTL
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
if client, homeMode, errClient := currentClaudeWebSearchResultKVClient(); homeMode {
|
|
if errClient != nil {
|
|
log.Errorf("home kv best-effort claude web search result set failed prefix=cpa:claude:*: %v", errClient)
|
|
return false
|
|
}
|
|
written, errSet := client.KVSet(ctx, "cpa:claude:web-search-result:"+key, bytes.Clone(content), homekv.KVSetOptions{EX: ttl})
|
|
if errSet != nil {
|
|
log.Errorf("home kv best-effort claude web search result set failed prefix=cpa:claude:*: %v", errSet)
|
|
return false
|
|
}
|
|
return written
|
|
}
|
|
if limit <= 0 {
|
|
limit = defaultClaudeWebSearchResultLimit
|
|
}
|
|
cacheCleanupOnce.Do(startCacheCleanup)
|
|
|
|
claudeWebSearchResultMu.Lock()
|
|
defer claudeWebSearchResultMu.Unlock()
|
|
|
|
now := claudeWebSearchResultNow()
|
|
if element, exists := claudeWebSearchResultIndex[key]; exists {
|
|
removeClaudeWebSearchResultLocked(element)
|
|
}
|
|
if claudeWebSearchResultOrder.Len() >= limit {
|
|
purgeExpiredClaudeWebSearchResultLocked(now)
|
|
}
|
|
entry := &claudeWebSearchResultEntry{
|
|
key: key,
|
|
content: bytes.Clone(content),
|
|
ttl: ttl,
|
|
expiresAt: now.Add(ttl),
|
|
}
|
|
claudeWebSearchResultIndex[key] = claudeWebSearchResultOrder.PushFront(entry)
|
|
for claudeWebSearchResultOrder.Len() > limit {
|
|
oldest := claudeWebSearchResultOrder.Back()
|
|
if oldest == nil {
|
|
break
|
|
}
|
|
removeClaudeWebSearchResultLocked(oldest)
|
|
}
|
|
return true
|
|
}
|
|
|
|
// GetClaudeWebSearchResult returns a copy of the stored content and extends its
|
|
// lifetime. Expired entries are removed and reported as missing.
|
|
func GetClaudeWebSearchResult(sessionKey, toolUseID string, ttl ...time.Duration) ([]byte, bool) {
|
|
content, ok, errGet := GetClaudeWebSearchResultRequired(context.Background(), sessionKey, toolUseID, ttl...)
|
|
if errGet != nil {
|
|
return nil, false
|
|
}
|
|
return content, ok
|
|
}
|
|
|
|
// GetClaudeWebSearchResultRequired retrieves a copy of the stored content for
|
|
// request-time paths and extends its lifetime.
|
|
func GetClaudeWebSearchResultRequired(ctx context.Context, sessionKey, toolUseID string, ttl ...time.Duration) ([]byte, bool, error) {
|
|
key, ok := claudeWebSearchResultKey(sessionKey, toolUseID)
|
|
if !ok {
|
|
return nil, false, nil
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
if client, homeMode, errClient := currentClaudeWebSearchResultKVClient(); homeMode {
|
|
if errClient != nil {
|
|
return nil, false, errClient
|
|
}
|
|
kvKey := "cpa:claude:web-search-result:" + key
|
|
raw, found, errGet := client.KVGet(ctx, kvKey)
|
|
if errGet != nil || !found || len(raw) == 0 {
|
|
return nil, false, errGet
|
|
}
|
|
effectiveTTL := defaultClaudeWebSearchResultTTL
|
|
if len(ttl) > 0 && ttl[0] > 0 {
|
|
effectiveTTL = ttl[0]
|
|
}
|
|
if _, errExpire := client.KVExpire(ctx, kvKey, effectiveTTL); errExpire != nil {
|
|
log.Warnf("home kv claude web search result expire failed prefix=cpa:claude:*: %v", errExpire)
|
|
}
|
|
return bytes.Clone(raw), true, nil
|
|
}
|
|
claudeWebSearchResultMu.Lock()
|
|
defer claudeWebSearchResultMu.Unlock()
|
|
|
|
element, exists := claudeWebSearchResultIndex[key]
|
|
if !exists {
|
|
return nil, false, nil
|
|
}
|
|
entry := element.Value.(*claudeWebSearchResultEntry)
|
|
now := claudeWebSearchResultNow()
|
|
if !now.Before(entry.expiresAt) {
|
|
removeClaudeWebSearchResultLocked(element)
|
|
return nil, false, nil
|
|
}
|
|
effectiveTTL := entry.ttl
|
|
if len(ttl) > 0 && ttl[0] > 0 {
|
|
effectiveTTL = ttl[0]
|
|
entry.ttl = effectiveTTL
|
|
}
|
|
if effectiveTTL <= 0 {
|
|
effectiveTTL = defaultClaudeWebSearchResultTTL
|
|
}
|
|
entry.expiresAt = now.Add(effectiveTTL)
|
|
claudeWebSearchResultOrder.MoveToFront(element)
|
|
return bytes.Clone(entry.content), true, nil
|
|
}
|
|
|
|
// ClearClaudeWebSearchResultCache removes every stored entry.
|
|
func ClearClaudeWebSearchResultCache() {
|
|
claudeWebSearchResultMu.Lock()
|
|
defer claudeWebSearchResultMu.Unlock()
|
|
claudeWebSearchResultIndex = make(map[string]*list.Element)
|
|
claudeWebSearchResultOrder.Init()
|
|
}
|
|
|
|
func purgeExpiredClaudeWebSearchResultCache(now time.Time) {
|
|
claudeWebSearchResultMu.Lock()
|
|
defer claudeWebSearchResultMu.Unlock()
|
|
purgeExpiredClaudeWebSearchResultLocked(now)
|
|
}
|
|
|
|
func purgeExpiredClaudeWebSearchResultLocked(now time.Time) {
|
|
for element := claudeWebSearchResultOrder.Back(); element != nil; {
|
|
prev := element.Prev()
|
|
entry := element.Value.(*claudeWebSearchResultEntry)
|
|
if !now.Before(entry.expiresAt) {
|
|
removeClaudeWebSearchResultLocked(element)
|
|
}
|
|
element = prev
|
|
}
|
|
}
|
|
|
|
func removeClaudeWebSearchResultLocked(element *list.Element) {
|
|
entry := element.Value.(*claudeWebSearchResultEntry)
|
|
delete(claudeWebSearchResultIndex, entry.key)
|
|
claudeWebSearchResultOrder.Remove(element)
|
|
}
|