sync update from LAN repo (source master @ c21a2a4a)
This commit is contained in:
1 parent
ea9dcff9c0
commit
66a443e915
140 files changed
+13777
-1040
No files matched your search
@@ -7,6 +7,7 @@ import logging
|
||||
import os
|
||||
import tempfile
|
||||
import threading
|
||||
from collections import OrderedDict
|
||||
from datetime import UTC, datetime
|
||||
from pathlib import Path
|
||||
|
||||
@@ -19,6 +20,14 @@ _USAGE_FILENAME = ".usage.json"
|
||||
# 单进程跑,故进程内锁即可保证状态流转不丢。
|
||||
_usage_lock = threading.Lock()
|
||||
|
||||
# One user run can first load SKILL.md and then execute several helper scripts.
|
||||
# Those are implementation details of one logical skill invocation, so retain a
|
||||
# small process-local LRU keyed by (run, skill) and increment the public counter
|
||||
# only once. A run stays on one worker; persistence across restarts is neither
|
||||
# needed nor desirable here.
|
||||
_MAX_RECENT_USE_EVENTS = 8192
|
||||
_recent_use_events: OrderedDict[tuple[str, str], None] = OrderedDict()
|
||||
|
||||
STATE_ACTIVE = "active"
|
||||
STATE_STALE = "stale"
|
||||
STATE_ARCHIVED = "archived"
|
||||
@@ -121,8 +130,110 @@ def bump_view(name: str) -> None:
|
||||
_update_entry(name, lambda e: {"view_count": e.get("view_count", 0) + 1, "last_viewed_at": _now_iso()})
|
||||
|
||||
|
||||
def bump_use(name: str) -> None:
|
||||
_update_entry(name, lambda e: {"use_count": e.get("use_count", 0) + 1, "last_used_at": _now_iso()})
|
||||
async def _increment_use_projection(name: str, use_count: int, used_at: datetime) -> None:
|
||||
"""Keep the MySQL skill-list projection current without importing ``app``."""
|
||||
try:
|
||||
from sqlalchemy import case, update
|
||||
|
||||
from deerflow.persistence.engine import get_session_factory
|
||||
from deerflow.persistence.skills.model import SkillRow
|
||||
|
||||
session_factory = get_session_factory()
|
||||
if session_factory is None:
|
||||
return
|
||||
async with session_factory() as session:
|
||||
await session.execute(
|
||||
update(SkillRow)
|
||||
.where(SkillRow.name == name)
|
||||
.values(
|
||||
# Fire-and-forget writes may finish out of order. Never let
|
||||
# an older absolute sidecar count overwrite a newer value.
|
||||
use_count=case((SkillRow.use_count < use_count, use_count), else_=SkillRow.use_count),
|
||||
last_activity_at=case(
|
||||
(SkillRow.last_activity_at.is_(None), used_at),
|
||||
(SkillRow.last_activity_at < used_at, used_at),
|
||||
else_=SkillRow.last_activity_at,
|
||||
),
|
||||
updated_at=case(
|
||||
(SkillRow.updated_at < used_at, used_at),
|
||||
else_=SkillRow.updated_at,
|
||||
),
|
||||
)
|
||||
)
|
||||
await session.commit()
|
||||
except Exception:
|
||||
logger.debug("Failed to update skill usage projection for %r", name, exc_info=True)
|
||||
|
||||
|
||||
def _schedule_use_projection_increment(name: str, use_count: int, used_at: datetime) -> None:
|
||||
"""Best-effort bridge from synchronous sandbox tools to the DB home loop."""
|
||||
try:
|
||||
from deerflow.persistence.engine import fire_and_forget_db_write
|
||||
|
||||
fire_and_forget_db_write(_increment_use_projection(name, use_count, used_at))
|
||||
except Exception:
|
||||
logger.debug("Failed to schedule skill usage projection for %r", name, exc_info=True)
|
||||
|
||||
|
||||
def runtime_use_event_key(runtime: Any | None) -> str | None:
|
||||
"""Return the stable user-run identifier carried by ``ToolRuntime``."""
|
||||
if runtime is None:
|
||||
return None
|
||||
context = getattr(runtime, "context", None)
|
||||
if isinstance(context, dict):
|
||||
for key in ("run_id", "langgraph_run_id"):
|
||||
value = context.get(key)
|
||||
if value is not None and str(value).strip():
|
||||
return str(value).strip()
|
||||
config = getattr(runtime, "config", None)
|
||||
if isinstance(config, dict):
|
||||
for bucket_name in ("configurable", "metadata"):
|
||||
bucket = config.get(bucket_name)
|
||||
if not isinstance(bucket, dict):
|
||||
continue
|
||||
for key in ("run_id", "langgraph_run_id"):
|
||||
value = bucket.get(key)
|
||||
if value is not None and str(value).strip():
|
||||
return str(value).strip()
|
||||
return None
|
||||
|
||||
|
||||
def bump_use(name: str, *, event_key: str | None = None) -> bool:
|
||||
"""Count one logical use, optionally de-duplicated by user run.
|
||||
|
||||
Returns ``True`` only when the counter changed. This makes callers and tests
|
||||
able to distinguish a new invocation from a second file/script access in
|
||||
the same run.
|
||||
"""
|
||||
normalized_name = str(name or "").strip()
|
||||
if not normalized_name:
|
||||
return False
|
||||
normalized_event = str(event_key or "").strip() or None
|
||||
dedupe_key = (normalized_event, normalized_name) if normalized_event else None
|
||||
used_at = datetime.now(UTC)
|
||||
new_count = 0
|
||||
try:
|
||||
with _usage_lock:
|
||||
if dedupe_key is not None and dedupe_key in _recent_use_events:
|
||||
_recent_use_events.move_to_end(dedupe_key)
|
||||
return False
|
||||
data = _read_all()
|
||||
entry = {**_DEFAULT_ENTRY, **data.get(normalized_name, {})}
|
||||
new_count = max(0, int(entry.get("use_count") or 0)) + 1
|
||||
entry.update({"use_count": new_count, "last_used_at": used_at.isoformat()})
|
||||
data[normalized_name] = entry
|
||||
_write_all(data)
|
||||
if dedupe_key is not None:
|
||||
_recent_use_events[dedupe_key] = None
|
||||
_recent_use_events.move_to_end(dedupe_key)
|
||||
while len(_recent_use_events) > _MAX_RECENT_USE_EVENTS:
|
||||
_recent_use_events.popitem(last=False)
|
||||
except Exception:
|
||||
logger.debug("Failed to bump usage entry for %r", normalized_name, exc_info=True)
|
||||
return False
|
||||
|
||||
_schedule_use_projection_increment(normalized_name, new_count, used_at)
|
||||
return True
|
||||
|
||||
|
||||
def bump_patch(name: str) -> None:
|
||||
|
||||
Reference in new issue
Block a user