LZH-YS1998
139 lines
3.8 KiB
Python
139 lines
3.8 KiB
Python
"""Pure external provider-session identity helpers.
|
|
|
|
Monitoring rows exist before an external CLI reports its real resumable
|
|
thread/session id. A synthetic ``agent:project:task`` id is useful for local
|
|
observability, but is never a provider resume capability.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Iterable
|
|
|
|
|
|
NON_RESUMABLE_EXTERNAL_SESSION_STATUSES: frozenset[str] = frozenset({
|
|
"failed",
|
|
"cancelled",
|
|
"denied",
|
|
"rejected",
|
|
"hard_timeout",
|
|
"idle_timeout",
|
|
"startup_timeout",
|
|
})
|
|
|
|
|
|
def external_session_status_allows_resume(status: Any) -> bool:
|
|
status = str(status or "").strip().lower()
|
|
return status not in NON_RESUMABLE_EXTERNAL_SESSION_STATUSES
|
|
|
|
|
|
def external_session_allows_resume(session: Any | None) -> bool:
|
|
return session is not None and external_session_status_allows_resume(
|
|
getattr(session, "status", "")
|
|
)
|
|
|
|
|
|
def is_provider_session_token(
|
|
token: Any,
|
|
*,
|
|
agent_type: str,
|
|
project_id: str,
|
|
) -> bool:
|
|
value = str(token or "").strip()
|
|
if not value:
|
|
return False
|
|
normalized_agent = str(agent_type or "").strip()
|
|
normalized_project = str(project_id or "default").strip() or "default"
|
|
if normalized_agent and value.startswith(
|
|
f"{normalized_agent}:{normalized_project}:"
|
|
):
|
|
return False
|
|
if normalized_agent and value.startswith(f"{normalized_agent}:"):
|
|
if len(value.split(":")) >= 3:
|
|
return False
|
|
return True
|
|
|
|
|
|
def provider_token_from_external_session(
|
|
session: Any | None,
|
|
*,
|
|
agent_type: str,
|
|
project_id: str,
|
|
) -> str:
|
|
if not external_session_allows_resume(session):
|
|
return ""
|
|
metadata = dict(getattr(session, "metadata", {}) or {})
|
|
for candidate in (
|
|
metadata.get("resume_session_id"),
|
|
metadata.get("provider_session_id"),
|
|
getattr(session, "session_id", ""),
|
|
):
|
|
token = str(candidate or "").strip()
|
|
if is_provider_session_token(
|
|
token,
|
|
agent_type=agent_type,
|
|
project_id=project_id,
|
|
):
|
|
return token
|
|
return ""
|
|
|
|
|
|
def external_session_matches_provider_token(
|
|
session: Any | None,
|
|
token: Any,
|
|
) -> bool:
|
|
"""Return whether a persisted row represents ``token`` regardless of status."""
|
|
|
|
if session is None:
|
|
return False
|
|
expected = str(token or "").strip()
|
|
if not expected:
|
|
return False
|
|
metadata = dict(getattr(session, "metadata", {}) or {})
|
|
return expected in {
|
|
str(candidate or "").strip()
|
|
for candidate in (
|
|
metadata.get("resume_session_id"),
|
|
metadata.get("provider_session_id"),
|
|
getattr(session, "session_id", ""),
|
|
)
|
|
if str(candidate or "").strip()
|
|
}
|
|
|
|
|
|
def select_best_external_resume_session(
|
|
sessions: Iterable[Any],
|
|
*,
|
|
agent_type: str,
|
|
project_id: str,
|
|
) -> tuple[Any | None, str]:
|
|
"""Select the newest valid provider capability, ignoring placeholders."""
|
|
|
|
valid: list[tuple[Any, str]] = []
|
|
normalized_agent = str(agent_type or "").strip()
|
|
for session in list(sessions or []):
|
|
if (
|
|
str(getattr(session, "agent_type", "") or "").strip()
|
|
!= normalized_agent
|
|
):
|
|
continue
|
|
token = provider_token_from_external_session(
|
|
session,
|
|
agent_type=normalized_agent,
|
|
project_id=project_id,
|
|
)
|
|
if token:
|
|
valid.append((session, token))
|
|
if not valid:
|
|
return None, ""
|
|
|
|
def _sort_key(item: tuple[Any, str]) -> tuple[float, str]:
|
|
session, token = item
|
|
updated_at = getattr(session, "updated_at", None)
|
|
try:
|
|
timestamp = float(updated_at.timestamp())
|
|
except Exception:
|
|
timestamp = 0.0
|
|
return timestamp, token
|
|
|
|
return max(valid, key=_sort_key)
|