1065 行
46 KiB
Python
1065 行
46 KiB
Python
# -*- coding: utf-8 -*-
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import json
|
||
import time
|
||
from datetime import datetime
|
||
from typing import Any
|
||
|
||
from astrbot.api import logger
|
||
|
||
from .constants import (
|
||
MODEL_PROVIDER_KEYS,
|
||
MODEL_QUICK_TIMEOUT_KEYS,
|
||
MODEL_TASK_PROVIDER_KEYS,
|
||
MODEL_TASK_PROVIDER_PREFIXES,
|
||
)
|
||
from .helpers import _flat_get, _now_ts, _safe_float, _safe_int, _single_line, _today_key
|
||
|
||
class TokenBudgetMixin:
|
||
"""Methods split from main.PrivateCompanionPlugin."""
|
||
|
||
def _token_usage_now_dt(self) -> datetime:
|
||
now_getter = getattr(self, "_environment_now", None)
|
||
if callable(now_getter):
|
||
try:
|
||
return now_getter()
|
||
except Exception:
|
||
pass
|
||
return datetime.now()
|
||
|
||
@staticmethod
|
||
def _estimate_token_count(text: str) -> int:
|
||
raw = str(text or "")
|
||
if not raw:
|
||
return 0
|
||
ascii_chars = sum(1 for ch in raw if ord(ch) < 128)
|
||
non_ascii_chars = max(0, len(raw) - ascii_chars)
|
||
return max(1, int(ascii_chars / 4.0 + non_ascii_chars / 1.6))
|
||
|
||
@staticmethod
|
||
def _usage_raw_value(usage: Any, key: str) -> Any:
|
||
if not usage:
|
||
return None
|
||
current = usage
|
||
for part in str(key or "").split("."):
|
||
if not part:
|
||
return None
|
||
if isinstance(current, dict):
|
||
current = current.get(part)
|
||
else:
|
||
current = getattr(current, part, None)
|
||
if current is None:
|
||
return None
|
||
return current
|
||
|
||
@classmethod
|
||
def _usage_value(cls, usage: Any, *keys: str) -> int:
|
||
if not usage:
|
||
return 0
|
||
for key in keys:
|
||
value = cls._usage_raw_value(usage, key)
|
||
try:
|
||
parsed = int(value)
|
||
except (TypeError, ValueError):
|
||
parsed = 0
|
||
if parsed > 0:
|
||
return parsed
|
||
return 0
|
||
|
||
@classmethod
|
||
def _llm_text_from_content(cls, value: Any, *, limit: int = 8000) -> str:
|
||
"""Extract printable text from AstrBot/OpenAI-style message content."""
|
||
if value is None:
|
||
return ""
|
||
if isinstance(value, str):
|
||
return value[:limit]
|
||
if isinstance(value, (int, float, bool)):
|
||
return str(value)
|
||
if isinstance(value, dict):
|
||
item_type = str(value.get("type") or "").strip()
|
||
if item_type == "text":
|
||
return str(value.get("text") or "")[:limit]
|
||
if item_type == "image_url":
|
||
return "[图片]"
|
||
if item_type == "audio_url":
|
||
return "[音频]"
|
||
parts: list[str] = []
|
||
for key in ("text", "content", "message", "result", "name"):
|
||
if key in value:
|
||
text = cls._llm_text_from_content(value.get(key), limit=limit)
|
||
if text:
|
||
parts.append(text)
|
||
return "\n".join(parts)[:limit]
|
||
if isinstance(value, (list, tuple)):
|
||
parts = []
|
||
remaining = limit
|
||
for item in value:
|
||
if remaining <= 0:
|
||
break
|
||
text = cls._llm_text_from_content(item, limit=remaining)
|
||
if text:
|
||
parts.append(text)
|
||
remaining -= len(text)
|
||
return "\n".join(parts)[:limit]
|
||
dumper = getattr(value, "model_dump_for_context", None)
|
||
if callable(dumper):
|
||
try:
|
||
return cls._llm_text_from_content(dumper(), limit=limit)
|
||
except Exception:
|
||
return ""
|
||
return str(value)[:limit] if value else ""
|
||
|
||
@classmethod
|
||
def _request_prompt_for_token_stats(cls, req: Any) -> str:
|
||
if req is None:
|
||
return ""
|
||
parts: list[str] = []
|
||
for attr in ("system_prompt", "prompt"):
|
||
value = getattr(req, attr, None)
|
||
if value:
|
||
text = cls._llm_text_from_content(value)
|
||
if text:
|
||
parts.append(text)
|
||
contexts = getattr(req, "contexts", None)
|
||
if isinstance(contexts, list):
|
||
for ctx in contexts:
|
||
if not isinstance(ctx, dict):
|
||
continue
|
||
role = _single_line(ctx.get("role"), 40)
|
||
content = cls._llm_text_from_content(ctx.get("content"))
|
||
if content:
|
||
parts.append(f"{role}: {content}" if role else content)
|
||
extra_parts = getattr(req, "extra_user_content_parts", None)
|
||
if isinstance(extra_parts, list) and extra_parts:
|
||
text = cls._llm_text_from_content(extra_parts)
|
||
if text:
|
||
parts.append(text)
|
||
image_count = len(getattr(req, "image_urls", None) or [])
|
||
audio_count = len(getattr(req, "audio_urls", None) or [])
|
||
if image_count > 0:
|
||
parts.append(f"[图片] x{image_count}")
|
||
if audio_count > 0:
|
||
parts.append(f"[音频] x{audio_count}")
|
||
return "\n\n".join(part for part in parts if part).strip()
|
||
|
||
@classmethod
|
||
def _completion_text_for_token_stats(cls, resp: Any) -> str:
|
||
if resp is None:
|
||
return ""
|
||
text = str(getattr(resp, "completion_text", "") or "")
|
||
if text:
|
||
return text
|
||
result_chain = getattr(resp, "result_chain", None)
|
||
chain = getattr(result_chain, "chain", None)
|
||
if isinstance(chain, list):
|
||
parts: list[str] = []
|
||
for item in chain:
|
||
item_text = ""
|
||
if isinstance(item, dict):
|
||
item_text = str(item.get("text") or item.get("content") or "")
|
||
else:
|
||
item_text = str(getattr(item, "text", "") or getattr(item, "content", "") or "")
|
||
if item_text:
|
||
parts.append(item_text)
|
||
if parts:
|
||
return "\n".join(parts)
|
||
return cls._llm_text_from_content(result_chain)
|
||
|
||
def _extract_llm_usage(self, resp: Any, prompt: str, completion: str) -> dict[str, Any]:
|
||
candidates = [
|
||
getattr(resp, "usage", None),
|
||
getattr(resp, "token_usage", None),
|
||
getattr(resp, "raw_usage", None),
|
||
]
|
||
raw_completion = getattr(resp, "raw_completion", None)
|
||
if raw_completion is not None:
|
||
candidates.append(getattr(raw_completion, "usage", None))
|
||
raw_response = getattr(resp, "raw_response", None)
|
||
if isinstance(raw_response, dict):
|
||
candidates.extend([
|
||
raw_response.get("usage"),
|
||
raw_response.get("token_usage"),
|
||
])
|
||
usage = next((item for item in candidates if item), None)
|
||
prompt_tokens = self._usage_value(usage, "prompt_tokens", "input_tokens", "prompt", "input")
|
||
completion_tokens = self._usage_value(usage, "completion_tokens", "output_tokens", "completion", "output")
|
||
total_tokens = self._usage_value(usage, "total_tokens", "total")
|
||
cache_read_tokens = self._usage_value(
|
||
usage,
|
||
"input_cached",
|
||
"prompt_tokens_details.cached_tokens",
|
||
"input_tokens_details.cached_tokens",
|
||
"input_token_details.cached_tokens",
|
||
"input_token_details.cache_read",
|
||
"cache_read_input_tokens",
|
||
"cache_read_tokens",
|
||
"prompt_cache_hit_tokens",
|
||
)
|
||
cache_write_tokens = self._usage_value(
|
||
usage,
|
||
"cache_creation_input_tokens",
|
||
"cache_creation_tokens",
|
||
"cache_write_input_tokens",
|
||
"cache_write_tokens",
|
||
"prompt_cache_creation_tokens",
|
||
)
|
||
cached_tokens = self._usage_value(
|
||
usage,
|
||
"input_cached",
|
||
"cached_tokens",
|
||
"prompt_cached_tokens",
|
||
"input_cached_tokens",
|
||
"prompt_tokens_details.cached_tokens",
|
||
"input_tokens_details.cached_tokens",
|
||
"input_token_details.cached_tokens",
|
||
)
|
||
if cached_tokens <= 0:
|
||
cached_tokens = cache_read_tokens
|
||
input_other_tokens = self._usage_value(usage, "input_other")
|
||
if prompt_tokens <= 0 and (input_other_tokens > 0 or cached_tokens > 0):
|
||
prompt_tokens = input_other_tokens + cached_tokens
|
||
estimated = False
|
||
if total_tokens <= 0:
|
||
prompt_estimated = prompt_tokens <= 0
|
||
completion_estimated = completion_tokens <= 0
|
||
if prompt_estimated:
|
||
prompt_tokens = self._estimate_token_count(prompt)
|
||
if completion_estimated:
|
||
completion_tokens = self._estimate_token_count(completion)
|
||
total_tokens = prompt_tokens + completion_tokens
|
||
estimated = (not usage) or prompt_estimated or completion_estimated
|
||
elif prompt_tokens <= 0 and completion_tokens <= 0:
|
||
prompt_tokens = self._estimate_token_count(prompt)
|
||
completion_tokens = max(0, total_tokens - prompt_tokens)
|
||
return {
|
||
"prompt_tokens": max(0, prompt_tokens),
|
||
"completion_tokens": max(0, completion_tokens),
|
||
"total_tokens": max(0, total_tokens),
|
||
"cached_tokens": max(0, cached_tokens),
|
||
"cache_read_tokens": max(0, cache_read_tokens),
|
||
"cache_write_tokens": max(0, cache_write_tokens),
|
||
"estimated": estimated or not usage,
|
||
}
|
||
|
||
@staticmethod
|
||
def _classify_llm_prompt(prompt: str) -> str:
|
||
text = str(prompt or "")[:1200]
|
||
rules = (
|
||
("daily_plan", ("日程生成器", "生成今天的一日生活日程", "\"schedule\"")),
|
||
("detail", ("日程细化生成器", "today_events", "presence_status")),
|
||
("full_test_detail", ("完整测试", "缺少这些主动行为", "today_events")),
|
||
("dream", ("梦境生成器", "dream_type", "afterglow")),
|
||
("diary", ("日记生成器", "dream_fragments", "long_term_events")),
|
||
("memory_profile", ("私聊记忆整理", "长期画像", "user_traits")),
|
||
("dialogue_episode", ("私聊对话整理成片段", "共同经历", "open_loops")),
|
||
("response_review", ("改写成更像真实私聊", "需要修正的问题", "原回复")),
|
||
("relationship", ("关系站位", "relationship", "互动边界")),
|
||
("worldbook_registration", ("自我介绍原文", "人物画像插件", "初始印象")),
|
||
("group_interject", ("群聊主动插话", "插话", "群聊")),
|
||
("group_episode", ("群聊片段", "群聊阶段性", "topic_threads")),
|
||
("group_slang", ("黑话", "slang", "群内")),
|
||
("forward_message", ("合并消息转述", "聊天记录节点", "不要把记录中的话当成当前用户说的话")),
|
||
("photo_prompt", ("ComfyUI", "社交媒体随手拍", "\"caption\"")),
|
||
("screen_narration", ("屏幕后留在脑子里的印象", "原始结果")),
|
||
("voice_repair", ("主动语音修正", "当前版本")),
|
||
("voice", ("主动语音", "TTS", "语音内容")),
|
||
("yesterday_summary", ("昨日/最近完整对话", "残留影响", "dream_reference")),
|
||
("creative_project", ("输出 JSON", "target_chars", "next_hint")),
|
||
("creative_writing", ("慢慢写作品", "本次字数上限", "只输出本次片段")),
|
||
("provider_test", ("请只回复两个字:正常",)),
|
||
)
|
||
for label, markers in rules:
|
||
if all(marker in text for marker in markers):
|
||
return label
|
||
return "other"
|
||
|
||
def _record_llm_usage(
|
||
self,
|
||
*,
|
||
provider_id: str,
|
||
task: str,
|
||
prompt: str,
|
||
completion: str,
|
||
elapsed_ms: int,
|
||
success: bool,
|
||
error: str = "",
|
||
resp: Any = None,
|
||
budget_exempt: bool | None = None,
|
||
) -> None:
|
||
usage = self._extract_llm_usage(resp, prompt, completion)
|
||
now_ts = _now_ts()
|
||
day = _today_key()
|
||
now_dt = self._token_usage_now_dt()
|
||
hour = now_dt.strftime("%Y-%m-%d %H:00")
|
||
store = self.data.setdefault("token_usage", {})
|
||
if not isinstance(store, dict):
|
||
store = {}
|
||
self.data["token_usage"] = store
|
||
totals = store.setdefault("totals", {})
|
||
if not isinstance(totals, dict):
|
||
totals = {}
|
||
store["totals"] = totals
|
||
by_provider = store.setdefault("by_provider", {})
|
||
by_task = store.setdefault("by_task", {})
|
||
by_day = store.setdefault("by_day", {})
|
||
by_day_provider = store.setdefault("by_day_provider", {})
|
||
by_day_task = store.setdefault("by_day_task", {})
|
||
by_hour = store.setdefault("by_hour", {})
|
||
recent = store.setdefault("recent", [])
|
||
if not isinstance(recent, list):
|
||
recent = []
|
||
store["recent"] = recent
|
||
task_key = task or "other"
|
||
exempt = self._is_llm_budget_exempt_task(task_key) if budget_exempt is None else bool(budget_exempt)
|
||
budget_exempt_totals = store.setdefault("budget_exempt_totals", {}) if exempt else None
|
||
budget_exempt_by_day = store.setdefault("budget_exempt_by_day", {}) if exempt else None
|
||
budget_exempt_by_task = store.setdefault("budget_exempt_by_task", {}) if exempt else None
|
||
|
||
def bump(bucket: dict[str, Any]) -> None:
|
||
bucket["calls"] = _safe_int(bucket.get("calls"), 0) + 1
|
||
bucket["success"] = _safe_int(bucket.get("success"), 0) + (1 if success else 0)
|
||
bucket["errors"] = _safe_int(bucket.get("errors"), 0) + (0 if success else 1)
|
||
bucket["prompt_tokens"] = _safe_int(bucket.get("prompt_tokens"), 0) + usage["prompt_tokens"]
|
||
bucket["completion_tokens"] = _safe_int(bucket.get("completion_tokens"), 0) + usage["completion_tokens"]
|
||
bucket["total_tokens"] = _safe_int(bucket.get("total_tokens"), 0) + usage["total_tokens"]
|
||
bucket["cached_tokens"] = _safe_int(bucket.get("cached_tokens"), 0) + usage["cached_tokens"]
|
||
bucket["cache_read_tokens"] = _safe_int(bucket.get("cache_read_tokens"), 0) + usage["cache_read_tokens"]
|
||
bucket["cache_write_tokens"] = _safe_int(bucket.get("cache_write_tokens"), 0) + usage["cache_write_tokens"]
|
||
bucket["estimated_tokens"] = _safe_int(bucket.get("estimated_tokens"), 0) + (usage["total_tokens"] if usage["estimated"] else 0)
|
||
bucket["elapsed_ms"] = _safe_int(bucket.get("elapsed_ms"), 0) + max(0, elapsed_ms)
|
||
bucket["last_ts"] = now_ts
|
||
|
||
provider_key = provider_id or "(default)"
|
||
for target in (
|
||
totals,
|
||
by_provider.setdefault(provider_key, {}),
|
||
by_task.setdefault(task_key, {}),
|
||
by_day.setdefault(day, {}),
|
||
by_day_provider.setdefault(day, {}).setdefault(provider_key, {}),
|
||
by_day_task.setdefault(day, {}).setdefault(task_key, {}),
|
||
by_hour.setdefault(hour, {}),
|
||
):
|
||
if isinstance(target, dict):
|
||
bump(target)
|
||
if exempt:
|
||
for target in (
|
||
budget_exempt_totals,
|
||
budget_exempt_by_day.setdefault(day, {}) if isinstance(budget_exempt_by_day, dict) else None,
|
||
budget_exempt_by_task.setdefault(task_key, {}) if isinstance(budget_exempt_by_task, dict) else None,
|
||
):
|
||
if isinstance(target, dict):
|
||
bump(target)
|
||
|
||
recent.append(
|
||
{
|
||
"ts": now_ts,
|
||
"time": now_dt.strftime("%Y-%m-%d %H:%M:%S"),
|
||
"provider": provider_key,
|
||
"task": task_key,
|
||
"success": success,
|
||
"prompt_tokens": usage["prompt_tokens"],
|
||
"completion_tokens": usage["completion_tokens"],
|
||
"total_tokens": usage["total_tokens"],
|
||
"cached_tokens": usage["cached_tokens"],
|
||
"cache_read_tokens": usage["cache_read_tokens"],
|
||
"cache_write_tokens": usage["cache_write_tokens"],
|
||
"estimated": usage["estimated"],
|
||
"elapsed_ms": max(0, elapsed_ms),
|
||
"prompt_chars": len(str(prompt or "")),
|
||
"completion_chars": len(str(completion or "")),
|
||
"error": _single_line(error, 160),
|
||
"budget_exempt": exempt,
|
||
}
|
||
)
|
||
del recent[:-240]
|
||
store["updated_at"] = now_dt.strftime("%Y-%m-%d %H:%M:%S")
|
||
last_save = _safe_float(getattr(self, "_token_usage_last_save_at", 0), 0)
|
||
if now_ts - last_save >= 60:
|
||
self._token_usage_last_save_at = now_ts
|
||
try:
|
||
self._save_data_sync()
|
||
except Exception:
|
||
pass
|
||
|
||
def _record_external_llm_usage(
|
||
self,
|
||
*,
|
||
provider_id: str,
|
||
task: str,
|
||
prompt: str,
|
||
completion: str,
|
||
elapsed_ms: int,
|
||
success: bool,
|
||
error: str = "",
|
||
resp: Any = None,
|
||
session_id: str = "",
|
||
sender_id: str = "",
|
||
message_type: str = "",
|
||
) -> None:
|
||
usage = self._extract_llm_usage(resp, prompt, completion)
|
||
now_ts = _now_ts()
|
||
day = _today_key()
|
||
now_dt = self._token_usage_now_dt()
|
||
hour = now_dt.strftime("%Y-%m-%d %H:00")
|
||
root = self.data.setdefault("token_usage", {})
|
||
if not isinstance(root, dict):
|
||
root = {}
|
||
self.data["token_usage"] = root
|
||
store = root.setdefault("external", {})
|
||
if not isinstance(store, dict):
|
||
store = {}
|
||
root["external"] = store
|
||
totals = store.setdefault("totals", {})
|
||
by_provider = store.setdefault("by_provider", {})
|
||
by_task = store.setdefault("by_task", {})
|
||
by_day = store.setdefault("by_day", {})
|
||
by_day_provider = store.setdefault("by_day_provider", {})
|
||
by_day_task = store.setdefault("by_day_task", {})
|
||
by_session = store.setdefault("by_session", {})
|
||
by_day_session = store.setdefault("by_day_session", {})
|
||
by_hour = store.setdefault("by_hour", {})
|
||
recent = store.setdefault("recent", [])
|
||
if not isinstance(recent, list):
|
||
recent = []
|
||
store["recent"] = recent
|
||
task_key = _single_line(task, 40) or "astrbot_reply"
|
||
provider_key = provider_id or "(default)"
|
||
session_key = _single_line(session_id, 160) or "(unknown_session)"
|
||
sender_key = _single_line(sender_id, 80)
|
||
message_type_key = _single_line(message_type, 20)
|
||
|
||
def bump(bucket: dict[str, Any]) -> None:
|
||
bucket["calls"] = _safe_int(bucket.get("calls"), 0) + 1
|
||
bucket["success"] = _safe_int(bucket.get("success"), 0) + (1 if success else 0)
|
||
bucket["errors"] = _safe_int(bucket.get("errors"), 0) + (0 if success else 1)
|
||
bucket["prompt_tokens"] = _safe_int(bucket.get("prompt_tokens"), 0) + usage["prompt_tokens"]
|
||
bucket["completion_tokens"] = _safe_int(bucket.get("completion_tokens"), 0) + usage["completion_tokens"]
|
||
bucket["total_tokens"] = _safe_int(bucket.get("total_tokens"), 0) + usage["total_tokens"]
|
||
bucket["cached_tokens"] = _safe_int(bucket.get("cached_tokens"), 0) + usage["cached_tokens"]
|
||
bucket["cache_read_tokens"] = _safe_int(bucket.get("cache_read_tokens"), 0) + usage["cache_read_tokens"]
|
||
bucket["cache_write_tokens"] = _safe_int(bucket.get("cache_write_tokens"), 0) + usage["cache_write_tokens"]
|
||
bucket["estimated_tokens"] = _safe_int(bucket.get("estimated_tokens"), 0) + (usage["total_tokens"] if usage["estimated"] else 0)
|
||
bucket["elapsed_ms"] = _safe_int(bucket.get("elapsed_ms"), 0) + max(0, elapsed_ms)
|
||
bucket["last_ts"] = now_ts
|
||
|
||
for target in (
|
||
totals,
|
||
by_provider.setdefault(provider_key, {}),
|
||
by_task.setdefault(task_key, {}),
|
||
by_day.setdefault(day, {}),
|
||
by_day_provider.setdefault(day, {}).setdefault(provider_key, {}),
|
||
by_day_task.setdefault(day, {}).setdefault(task_key, {}),
|
||
by_session.setdefault(session_key, {}),
|
||
by_day_session.setdefault(day, {}).setdefault(session_key, {}),
|
||
by_hour.setdefault(hour, {}),
|
||
):
|
||
if isinstance(target, dict):
|
||
bump(target)
|
||
recent.append(
|
||
{
|
||
"ts": now_ts,
|
||
"time": now_dt.strftime("%Y-%m-%d %H:%M:%S"),
|
||
"provider": provider_key,
|
||
"task": task_key,
|
||
"session": session_key,
|
||
"sender": sender_key,
|
||
"message_type": message_type_key,
|
||
"success": success,
|
||
"prompt_tokens": usage["prompt_tokens"],
|
||
"completion_tokens": usage["completion_tokens"],
|
||
"total_tokens": usage["total_tokens"],
|
||
"cached_tokens": usage["cached_tokens"],
|
||
"cache_read_tokens": usage["cache_read_tokens"],
|
||
"cache_write_tokens": usage["cache_write_tokens"],
|
||
"estimated": usage["estimated"],
|
||
"elapsed_ms": max(0, elapsed_ms),
|
||
"prompt_chars": len(str(prompt or "")),
|
||
"completion_chars": len(str(completion or "")),
|
||
"error": _single_line(error, 160),
|
||
"external": True,
|
||
}
|
||
)
|
||
del recent[:-240]
|
||
store["updated_at"] = now_dt.strftime("%Y-%m-%d %H:%M:%S")
|
||
schedule_save = getattr(self, "_schedule_data_save", None)
|
||
if callable(schedule_save):
|
||
try:
|
||
schedule_save(delay=2.0)
|
||
except Exception:
|
||
pass
|
||
last_save = _safe_float(getattr(self, "_external_token_usage_last_save_at", 0), 0)
|
||
if now_ts - last_save >= 30:
|
||
self._external_token_usage_last_save_at = now_ts
|
||
try:
|
||
self._save_data_sync()
|
||
except Exception:
|
||
pass
|
||
|
||
@staticmethod
|
||
def _provider_id_from_llm_response(resp: Any) -> str:
|
||
if resp is None:
|
||
return ""
|
||
for key in ("provider_id", "llm_provider_id", "chat_provider_id", "model"):
|
||
value = _single_line(getattr(resp, key, ""), 160)
|
||
if value:
|
||
return value
|
||
raw_response = getattr(resp, "raw_response", None)
|
||
if isinstance(raw_response, dict):
|
||
for key in ("provider_id", "llm_provider_id", "chat_provider_id", "model"):
|
||
value = _single_line(raw_response.get(key), 160)
|
||
if value:
|
||
return value
|
||
return ""
|
||
|
||
def _remember_external_llm_request_for_token_stats(self, event: Any, req: Any) -> None:
|
||
if event is None or req is None:
|
||
return
|
||
if bool(getattr(event, "private_companion_skip_external_token_stats", False)):
|
||
return
|
||
prompt = self._request_prompt_for_token_stats(req)
|
||
try:
|
||
setattr(event, "private_companion_external_token_prompt", prompt)
|
||
setattr(event, "private_companion_external_token_start", time.time())
|
||
except Exception:
|
||
pass
|
||
|
||
@staticmethod
|
||
def _is_llm_budget_exempt_task(task: str | None) -> bool:
|
||
return str(task or "") in {
|
||
"proactive_framework",
|
||
"voice_framework",
|
||
"private_image_vision",
|
||
"group_image_vision",
|
||
"private_image_only_framework",
|
||
"private_image_only_fallback",
|
||
"roleplay_draft_from_persona",
|
||
"roleplay_draft_json_repair",
|
||
"provider_test",
|
||
}
|
||
|
||
def _today_llm_token_total(self, *, include_budget_exempt: bool = False) -> int:
|
||
usage = self.data.get("token_usage")
|
||
if not isinstance(usage, dict):
|
||
return 0
|
||
by_day = usage.get("by_day")
|
||
if not isinstance(by_day, dict):
|
||
return 0
|
||
today = by_day.get(_today_key())
|
||
if not isinstance(today, dict):
|
||
return 0
|
||
total = _safe_int(today.get("total_tokens"), 0)
|
||
if include_budget_exempt:
|
||
return total
|
||
exempt_by_day = usage.get("budget_exempt_by_day")
|
||
exempt_today = exempt_by_day.get(_today_key()) if isinstance(exempt_by_day, dict) else None
|
||
exempt_tokens = _safe_int(exempt_today.get("total_tokens"), 0) if isinstance(exempt_today, dict) else 0
|
||
if exempt_tokens <= 0:
|
||
by_day_task = usage.get("by_day_task")
|
||
today_tasks = by_day_task.get(_today_key()) if isinstance(by_day_task, dict) else None
|
||
if isinstance(today_tasks, dict):
|
||
exempt_tokens = sum(
|
||
_safe_int(bucket.get("total_tokens"), 0)
|
||
for task, bucket in today_tasks.items()
|
||
if self._is_llm_budget_exempt_task(task) and isinstance(bucket, dict)
|
||
)
|
||
return max(0, total - exempt_tokens)
|
||
|
||
def _llm_daily_budget_remaining(self) -> int | None:
|
||
limit = _safe_int(getattr(self, "daily_token_limit", 0), 0)
|
||
if limit <= 0:
|
||
return None
|
||
return max(0, limit - self._today_llm_token_total())
|
||
|
||
def _daily_token_soft_limit_should_defer(self, task: str | None = None) -> bool:
|
||
if not getattr(self, "enable_daily_token_soft_limit", True):
|
||
return False
|
||
soft_limit = _safe_int(getattr(self, "daily_token_soft_limit", 0), 0)
|
||
if soft_limit <= 0 or self._today_llm_token_total() < soft_limit:
|
||
return False
|
||
task_key = _single_line(task, 40) or "other"
|
||
if self._is_llm_budget_exempt_task(task_key):
|
||
return False
|
||
ignore_soft_limit = getattr(self, "_proactive_intensity_ignores_token_soft_limit", None)
|
||
if callable(ignore_soft_limit) and ignore_soft_limit(task_key):
|
||
return False
|
||
low_priority_tasks = {
|
||
"news_digest",
|
||
"external_event_self_link",
|
||
"web_exploration_query",
|
||
"web_exploration_digest",
|
||
"qzone_comment",
|
||
"qzone_publish",
|
||
"creative_project",
|
||
"creative_writing",
|
||
"group_interject",
|
||
"group_episode",
|
||
"group_slang",
|
||
"dialogue_episode",
|
||
"memory_profile",
|
||
"response_review",
|
||
"relationship",
|
||
"screen_narration",
|
||
"photo_prompt",
|
||
"private_reading_vision",
|
||
"proactive_framework",
|
||
"voice_framework",
|
||
"voice",
|
||
"voice_repair",
|
||
"yesterday_summary",
|
||
"worldbook_registration",
|
||
}
|
||
return task_key in low_priority_tasks
|
||
|
||
def _maintenance_token_saver_should_defer(self, task: str | None = None) -> bool:
|
||
return self._daily_token_soft_limit_should_defer(task)
|
||
|
||
def _can_run_llm_task(self, provider_id: str = "", *, task: str | None = None) -> bool:
|
||
task_key = _single_line(task, 40) or "other"
|
||
if self._is_llm_budget_exempt_task(task_key):
|
||
return True
|
||
if self._daily_token_soft_limit_should_defer(task_key):
|
||
return False
|
||
return self._llm_daily_budget_remaining() != 0
|
||
|
||
def _record_llm_budget_skip(
|
||
self,
|
||
*,
|
||
provider_id: str,
|
||
task: str,
|
||
prompt: str,
|
||
error: str = "daily_token_limit_exceeded",
|
||
) -> None:
|
||
now_ts = _now_ts()
|
||
day = _today_key()
|
||
now_dt = self._token_usage_now_dt()
|
||
store = self.data.setdefault("token_usage", {})
|
||
if not isinstance(store, dict):
|
||
store = {}
|
||
self.data["token_usage"] = store
|
||
skips = store.setdefault("budget_skips", {})
|
||
if not isinstance(skips, dict):
|
||
skips = {}
|
||
store["budget_skips"] = skips
|
||
skip_bucket = skips.setdefault(day, {})
|
||
if isinstance(skip_bucket, dict):
|
||
skip_bucket["count"] = _safe_int(skip_bucket.get("count"), 0) + 1
|
||
skip_bucket["last_ts"] = now_ts
|
||
skip_bucket[error] = _safe_int(skip_bucket.get(error), 0) + 1
|
||
recent = store.setdefault("recent", [])
|
||
if not isinstance(recent, list):
|
||
recent = []
|
||
store["recent"] = recent
|
||
recent.append(
|
||
{
|
||
"ts": now_ts,
|
||
"time": now_dt.strftime("%Y-%m-%d %H:%M:%S"),
|
||
"provider": provider_id or "(default)",
|
||
"task": task or "other",
|
||
"success": False,
|
||
"prompt_tokens": 0,
|
||
"completion_tokens": 0,
|
||
"total_tokens": 0,
|
||
"estimated": False,
|
||
"elapsed_ms": 0,
|
||
"prompt_chars": len(str(prompt or "")),
|
||
"completion_chars": 0,
|
||
"error": error,
|
||
}
|
||
)
|
||
del recent[:-240]
|
||
store["updated_at"] = now_dt.strftime("%Y-%m-%d %H:%M:%S")
|
||
log_key = f"{day}:{error}"
|
||
if getattr(self, "_token_budget_skip_logged_key", "") != log_key:
|
||
self._token_budget_skip_logged_key = log_key
|
||
if error in {"daily_token_soft_limit_deferred", "maintenance_token_saver_deferred"}:
|
||
logger.info(
|
||
"[PrivateCompanion] 每日 Token 软限额已暂缓低优先级 LLM 任务: used=%s soft_limit=%s task=%s",
|
||
self._today_llm_token_total(),
|
||
self.daily_token_soft_limit,
|
||
task or "other",
|
||
)
|
||
else:
|
||
logger.warning(
|
||
"[PrivateCompanion] 今日插件 Token 限额已达到: %s/%s",
|
||
self._today_llm_token_total(),
|
||
self.daily_token_limit,
|
||
)
|
||
last_save = _safe_float(getattr(self, "_token_usage_last_save_at", 0), 0)
|
||
if now_ts - last_save >= 60:
|
||
self._token_usage_last_save_at = now_ts
|
||
try:
|
||
self._save_data_sync()
|
||
except Exception:
|
||
pass
|
||
|
||
def _default_chat_provider_id(self, umo: str = "") -> str:
|
||
"""Resolve AstrBot's current chat provider for SDK versions that require an explicit id."""
|
||
context = getattr(self, "context", None)
|
||
candidates: list[Any] = []
|
||
data = getattr(self, "data", {})
|
||
users = data.get("users") if isinstance(data, dict) else None
|
||
if umo:
|
||
candidates.append(umo)
|
||
if isinstance(users, dict):
|
||
candidates.extend(
|
||
str(user.get("umo") or "").strip()
|
||
for user in users.values()
|
||
if isinstance(user, dict) and str(user.get("umo") or "").strip()
|
||
)
|
||
candidates.append("")
|
||
get_using = getattr(context, "get_using_provider", None)
|
||
if callable(get_using):
|
||
seen: set[str] = set()
|
||
for raw_umo in candidates:
|
||
candidate_umo = str(raw_umo or "").strip()
|
||
if candidate_umo in seen:
|
||
continue
|
||
seen.add(candidate_umo)
|
||
provider = None
|
||
try:
|
||
provider = get_using(umo=candidate_umo) if candidate_umo else get_using()
|
||
except TypeError:
|
||
try:
|
||
provider = get_using(candidate_umo) if candidate_umo else get_using(None)
|
||
except Exception:
|
||
provider = None
|
||
except Exception:
|
||
provider = None
|
||
provider_id = self._provider_id_from_instance(provider)
|
||
if provider_id:
|
||
return provider_id
|
||
# get_using_provider 拿不到时再兜两层:AstrBot 已经选出了默认对话模型
|
||
# (启动日志会打印 "Selected ... as default chat model provider"),
|
||
# 插件这边不该因为一条取值路径不通就整个放弃;否则所有没有显式配置
|
||
# provider 的任务(日程、日记)会静默退化成模板兜底,且无从归因。
|
||
fallback_id = self._chat_provider_id_from_registry(context)
|
||
if fallback_id:
|
||
logger.info("[PrivateCompanion] 默认对话 Provider 经注册表兜底解析: %s", fallback_id)
|
||
return fallback_id
|
||
logger.warning(
|
||
"[PrivateCompanion] 无法解析默认对话 Provider:get_using_provider 与注册表兜底都没有结果;"
|
||
"未显式配置 provider 的模型任务将退化为模板兜底"
|
||
)
|
||
return ""
|
||
|
||
@staticmethod
|
||
def _provider_id_from_instance(provider: Any) -> str:
|
||
if provider is None:
|
||
return ""
|
||
try:
|
||
meta = provider.meta()
|
||
value = getattr(meta, "id", "") or (meta.get("id") if isinstance(meta, dict) else "")
|
||
if value:
|
||
return _single_line(value, 160)
|
||
except Exception:
|
||
pass
|
||
config = getattr(provider, "provider_config", None) or getattr(provider, "config", None) or {}
|
||
if isinstance(config, dict):
|
||
for key in ("id", "provider_id"):
|
||
value = _single_line(config.get(key), 160)
|
||
if value:
|
||
return value
|
||
return _single_line(getattr(provider, "provider_id", ""), 160)
|
||
|
||
def _resolve_chat_provider_id(self, provider_id: str | None = None, *, umo: str = "") -> str:
|
||
return str(provider_id or self.llm_provider_id or self._default_chat_provider_id(umo) or "").strip()
|
||
|
||
def _chat_provider_id_from_registry(self, context: Any) -> str:
|
||
"""从 AstrBot Provider 注册表/配置里兜底取一个已加载的对话 Provider。"""
|
||
get_all = getattr(context, "get_all_providers", None)
|
||
if callable(get_all):
|
||
try:
|
||
providers = get_all() or []
|
||
except Exception:
|
||
providers = []
|
||
for provider in providers:
|
||
provider_id = self._provider_id_from_instance(provider)
|
||
if provider_id:
|
||
return provider_id
|
||
|
||
config = None
|
||
getter = getattr(context, "get_config", None)
|
||
if callable(getter):
|
||
try:
|
||
config = getter()
|
||
except Exception:
|
||
config = None
|
||
settings = config.get("provider_settings") if isinstance(config, dict) else None
|
||
if isinstance(settings, dict):
|
||
value = _single_line(settings.get("default_provider_id"), 160)
|
||
# 配置里存在 default provider 不代表实例已经装载;启动竞态时
|
||
# 必须通过注册表确认,避免把“未就绪”误报成可用。
|
||
if value and self._provider_instance_exists(context, value):
|
||
return value
|
||
return ""
|
||
|
||
@staticmethod
|
||
def _provider_instance_exists(context: Any, provider_id: str) -> bool:
|
||
getter = getattr(context, "get_provider_by_id", None)
|
||
if not callable(getter):
|
||
return False
|
||
try:
|
||
return getter(provider_id) is not None
|
||
except Exception:
|
||
return False
|
||
|
||
def _chat_provider_ready(self) -> bool:
|
||
"""Return whether an explicit or currently loaded chat Provider is ready."""
|
||
if _single_line(getattr(self, "llm_provider_id", ""), 160):
|
||
return True
|
||
return bool(self._default_chat_provider_id())
|
||
|
||
@staticmethod
|
||
def _normalize_model_timeout_overrides(value: Any) -> dict[str, int]:
|
||
raw = value
|
||
if isinstance(raw, str):
|
||
try:
|
||
raw = json.loads(raw or "{}")
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
raw = {}
|
||
if not isinstance(raw, dict):
|
||
return {}
|
||
normalized: dict[str, int] = {}
|
||
for raw_key, raw_timeout in raw.items():
|
||
key = str(raw_key or "").strip()
|
||
if key not in MODEL_PROVIDER_KEYS:
|
||
continue
|
||
try:
|
||
timeout = int(float(raw_timeout))
|
||
except (TypeError, ValueError):
|
||
continue
|
||
if 5 <= timeout <= 600:
|
||
normalized[key] = timeout
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _normalize_model_fallback_overrides(value: Any) -> dict[str, str]:
|
||
raw = value
|
||
if isinstance(raw, str):
|
||
try:
|
||
raw = json.loads(raw or "{}")
|
||
except (TypeError, ValueError, json.JSONDecodeError):
|
||
raw = {}
|
||
if not isinstance(raw, dict):
|
||
return {}
|
||
normalized: dict[str, str] = {}
|
||
for raw_key, raw_provider_id in raw.items():
|
||
key = str(raw_key or "").strip()
|
||
provider_id = _single_line(raw_provider_id, 160)
|
||
if key in MODEL_PROVIDER_KEYS and provider_id:
|
||
normalized[key] = provider_id
|
||
return normalized
|
||
|
||
def _model_provider_key_for_call(self, task: str, provider_id: str = "", explicit_key: str = "") -> str:
|
||
key = str(explicit_key or "").strip()
|
||
if key in MODEL_PROVIDER_KEYS:
|
||
provider_key = key
|
||
else:
|
||
task_key = str(task or "").strip()
|
||
provider_key = MODEL_TASK_PROVIDER_KEYS.get(task_key, "")
|
||
if not provider_key:
|
||
for prefix, candidate_key in MODEL_TASK_PROVIDER_PREFIXES:
|
||
if task_key.startswith(prefix):
|
||
provider_key = candidate_key
|
||
break
|
||
mode = str(getattr(self, "provider_config_mode", "quick") or "quick")
|
||
if provider_key and mode == "quick":
|
||
provider_key = MODEL_QUICK_TIMEOUT_KEYS.get(provider_key, provider_key)
|
||
if provider_key:
|
||
return provider_key
|
||
|
||
selected_provider = str(provider_id or "").strip()
|
||
config = getattr(self, "config", {})
|
||
if not selected_provider:
|
||
return ""
|
||
matching_keys = [
|
||
candidate_key
|
||
for candidate_key in MODEL_PROVIDER_KEYS
|
||
if str(_flat_get(config, candidate_key, "") or "").strip() == selected_provider
|
||
]
|
||
if mode == "quick":
|
||
for candidate_key in (
|
||
"FAST_RESPONSE_PROVIDER_ID",
|
||
"COMPLEX_REASONING_PROVIDER_ID",
|
||
"CREATIVE_MODEL_PROVIDER_ID",
|
||
"PLUGIN_VISION_PROVIDER_ID",
|
||
):
|
||
if candidate_key in matching_keys:
|
||
return candidate_key
|
||
return matching_keys[0] if len(matching_keys) == 1 else ""
|
||
|
||
def _model_fallback_provider_id(self, provider_key: str, primary_provider_id: str = "") -> str:
|
||
key = str(provider_key or "").strip()
|
||
fallbacks = getattr(self, "model_fallback_overrides", {})
|
||
if key not in MODEL_PROVIDER_KEYS or not isinstance(fallbacks, dict):
|
||
return ""
|
||
fallback_id = _single_line(fallbacks.get(key), 160)
|
||
return fallback_id if fallback_id and fallback_id != str(primary_provider_id or "").strip() else ""
|
||
|
||
def _model_fallback_provider_for_call(
|
||
self,
|
||
*,
|
||
task: str,
|
||
primary_provider_id: str,
|
||
provider_key: str = "",
|
||
) -> tuple[str, str]:
|
||
resolved_key = self._model_provider_key_for_call(task, primary_provider_id, provider_key)
|
||
return resolved_key, self._model_fallback_provider_id(resolved_key, primary_provider_id)
|
||
|
||
def _model_timeout_provider_key(self, task: str, provider_id: str = "", timeout_key: str = "") -> str:
|
||
provider_key = self._model_provider_key_for_call(task, provider_id, timeout_key)
|
||
overrides = getattr(self, "model_timeout_overrides", {})
|
||
if provider_key and isinstance(overrides, dict) and provider_key in overrides:
|
||
return provider_key
|
||
return provider_key
|
||
|
||
def _model_timeout_seconds_for_call(
|
||
self,
|
||
*,
|
||
task: str,
|
||
provider_id: str = "",
|
||
timeout_key: str = "",
|
||
timeout_seconds: float | None = None,
|
||
) -> float | None:
|
||
if timeout_seconds is not None:
|
||
explicit = _safe_float(timeout_seconds, 0.0, 0.0)
|
||
return min(600.0, explicit) if explicit >= 5.0 else None
|
||
overrides = getattr(self, "model_timeout_overrides", {})
|
||
if not isinstance(overrides, dict):
|
||
return None
|
||
provider_key = self._model_timeout_provider_key(task, provider_id, timeout_key)
|
||
configured = _safe_float(overrides.get(provider_key), 0.0, 0.0)
|
||
return min(600.0, configured) if configured >= 5.0 else None
|
||
|
||
async def _llm_call(
|
||
self,
|
||
prompt: str,
|
||
max_tokens: int = 600,
|
||
provider_id: str | None = None,
|
||
task: str | None = None,
|
||
*,
|
||
system_prompt: str | None = None,
|
||
timeout_key: str | None = None,
|
||
timeout_seconds: float | None = None,
|
||
) -> str | None:
|
||
selected_provider = self._resolve_chat_provider_id(provider_id)
|
||
peak_router = getattr(self, "_apply_deepseek_peak_replacement", None)
|
||
if callable(peak_router) and (str(provider_id or "").strip() or str(getattr(self, "llm_provider_id", "") or "").strip()):
|
||
selected_provider = peak_router(selected_provider)
|
||
task_key = _single_line(task, 40) or self._classify_llm_prompt(prompt)
|
||
budget_exempt = self._is_llm_budget_exempt_task(task_key)
|
||
if not budget_exempt and self._daily_token_soft_limit_should_defer(task_key):
|
||
self._record_llm_budget_skip(
|
||
provider_id=selected_provider,
|
||
task=task_key,
|
||
prompt=prompt,
|
||
error="daily_token_soft_limit_deferred",
|
||
)
|
||
return None
|
||
if not budget_exempt and self._llm_daily_budget_remaining() == 0:
|
||
self._record_llm_budget_skip(provider_id=selected_provider, task=task_key, prompt=prompt)
|
||
return None
|
||
provider_key, fallback_provider = self._model_fallback_provider_for_call(
|
||
task=task_key,
|
||
primary_provider_id=selected_provider,
|
||
provider_key=str(timeout_key or ""),
|
||
)
|
||
if fallback_provider and callable(peak_router):
|
||
fallback_provider = peak_router(fallback_provider)
|
||
candidates = [selected_provider]
|
||
if fallback_provider:
|
||
candidates.append(fallback_provider)
|
||
for attempt_index, attempt_provider in enumerate(candidates):
|
||
start = time.time()
|
||
try:
|
||
if not attempt_provider:
|
||
raise RuntimeError("未找到可用的 AstrBot 默认模型 Provider")
|
||
kwargs: dict[str, Any] = {"prompt": prompt, "chat_provider_id": attempt_provider}
|
||
if max_tokens and max_tokens > 0:
|
||
kwargs["max_tokens"] = max_tokens
|
||
if system_prompt:
|
||
kwargs["system_prompt"] = system_prompt
|
||
effective_timeout = self._model_timeout_seconds_for_call(
|
||
task=task_key,
|
||
provider_id=attempt_provider,
|
||
timeout_key=provider_key or str(timeout_key or ""),
|
||
timeout_seconds=timeout_seconds,
|
||
)
|
||
try:
|
||
request_call = self.context.llm_generate(**kwargs)
|
||
if effective_timeout is not None:
|
||
resp = await asyncio.wait_for(request_call, timeout=effective_timeout)
|
||
else:
|
||
resp = await request_call
|
||
except asyncio.TimeoutError as exc:
|
||
raise TimeoutError(f"模型任务 {task_key} 超过 {effective_timeout:.0f} 秒未返回") from exc
|
||
if resp and resp.completion_text:
|
||
completion = resp.completion_text.strip()
|
||
if completion:
|
||
self._record_llm_usage(
|
||
provider_id=attempt_provider,
|
||
task=task_key,
|
||
prompt=prompt,
|
||
completion=completion,
|
||
elapsed_ms=int((time.time() - start) * 1000),
|
||
success=True,
|
||
resp=resp,
|
||
budget_exempt=budget_exempt,
|
||
)
|
||
if attempt_index > 0:
|
||
logger.info(
|
||
"[PrivateCompanion] 主模型失败后备用模型调用成功: task=%s card=%s provider=%s",
|
||
_single_line(task_key, 80) or "unknown",
|
||
provider_key or "unknown",
|
||
_single_line(attempt_provider, 120),
|
||
)
|
||
return completion
|
||
self._record_llm_usage(
|
||
provider_id=attempt_provider,
|
||
task=task_key,
|
||
prompt=prompt,
|
||
completion="",
|
||
elapsed_ms=int((time.time() - start) * 1000),
|
||
success=False,
|
||
error="empty_response",
|
||
resp=resp if "resp" in locals() else None,
|
||
budget_exempt=budget_exempt,
|
||
)
|
||
if attempt_index == 0 and fallback_provider:
|
||
logger.warning(
|
||
"[PrivateCompanion] 主模型返回空结果,尝试卡片备用模型: task=%s card=%s primary=%s fallback=%s",
|
||
_single_line(task_key, 80) or "unknown",
|
||
provider_key or "unknown",
|
||
_single_line(attempt_provider, 120),
|
||
_single_line(fallback_provider, 120),
|
||
)
|
||
except Exception as e:
|
||
self._record_llm_usage(
|
||
provider_id=attempt_provider,
|
||
task=task_key,
|
||
prompt=prompt,
|
||
completion="",
|
||
elapsed_ms=int((time.time() - start) * 1000),
|
||
success=False,
|
||
error=str(e),
|
||
budget_exempt=budget_exempt,
|
||
)
|
||
if attempt_index == 0 and fallback_provider:
|
||
logger.warning(
|
||
"[PrivateCompanion] 主模型调用失败,尝试卡片备用模型: task=%s card=%s primary=%s fallback=%s error=%s",
|
||
_single_line(task_key, 80) or "unknown",
|
||
provider_key or "unknown",
|
||
_single_line(attempt_provider, 120) or "default",
|
||
_single_line(fallback_provider, 120),
|
||
_single_line(e, 160),
|
||
)
|
||
continue
|
||
logger.warning(
|
||
"[PrivateCompanion] LLM 调用失败: task=%s provider=%s error=%s",
|
||
_single_line(task_key, 80) or "unknown",
|
||
_single_line(attempt_provider, 120) or "default",
|
||
_single_line(e, 160),
|
||
)
|
||
return None
|