astrbot_plugin_private_comp.../token_budget.py

1065 行
46 KiB
Python

此文件含有模棱两可的 Unicode 字符

此文件含有可能会与其他字符混淆的 Unicode 字符。 如果您是想特意这样的,可以安全地忽略该警告。 使用 Escape 按钮显示他们。

# -*- 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