This commit is contained in:
Lars committed 2026-08-29 20:28:59 +02:00
1 parent be11f82f84
commit e42f751fdc
47 files changed
+3359 -301

No files matched your search

+181 -3
View File
@@ -85,6 +85,20 @@ COMPACT_DIAGNOSTIC_KEYS = (
"detect_cost",
"detect_ms",
"generate_called",
"generate_requested",
"http_status",
"provider_message",
"provider_code",
"timeout_s",
"cost_report",
"detect_passes",
"detect_partial_discarded",
"detect_attempts",
"contract_violation",
"invalid_entity_type",
"detect_cost_unknown",
"generation_selection",
"style_application",
)
ERROR_EGRESS_VALIDATION = "egress_validation_failed"
@@ -165,14 +179,159 @@ class MaskingManifest:
}
def _snapshot_plain(value: Any, *, _stack: set[int] | None = None) -> Any:
"""Acyclic copy of compact diagnostic values. Drops cyclic back-references."""
if value is None or isinstance(value, (str, int, float, bool)):
return value
if isinstance(value, (dict, list, tuple)):
stack = _stack or set()
ident = id(value)
if ident in stack:
return None
stack = set(stack)
stack.add(ident)
if isinstance(value, dict):
return {
str(key): _snapshot_plain(item, _stack=stack)
for key, item in value.items()
if key not in {"trace", "diagnostics", "intern", "egress", "raw", "reply", "prompt", "messages"}
}
return [_snapshot_plain(item, _stack=stack) for item in value]
return value
def compact_diagnostics(data: dict[str, Any] | None) -> dict[str, Any]:
payload = {}
for key in COMPACT_DIAGNOSTIC_KEYS:
if data and key in data and data[key] is not None:
payload[key] = data[key]
payload[key] = _snapshot_plain(data[key])
return payload
def _as_cost(value: Any) -> float | None:
if value is None or value == "":
return None
try:
return float(value)
except (TypeError, ValueError):
return None
def _format_usd(value: float) -> str:
text = f"{value:.6f}".rstrip("0").rstrip(".")
return f"{text.replace('.', ',')} USD"
def _first_present(*values: Any) -> Any:
for value in values:
if value is not None:
return value
return None
def public_cost_report(diagnostics: dict[str, Any] | None) -> dict[str, Any]:
"""User-facing billed/unbilled summary. No prompts, no mapping labels."""
data = diagnostics or {}
nested = data.get("trace") if isinstance(data.get("trace"), dict) else {}
budget = nested.get("budget") if isinstance(nested.get("budget"), dict) else {}
generate_called = bool(
data.get("generate_called")
or data.get("generate_calls")
or nested.get("generate_called")
or nested.get("generate_calls")
)
generate_requested = bool(
data.get("generate_requested")
or nested.get("generate_requested")
or generate_called
)
detect_calls = _first_present(data.get("detect_calls"), nested.get("detect_calls"))
try:
detect_calls_n = int(detect_calls) if detect_calls is not None else 0
except (TypeError, ValueError):
detect_calls_n = 0
detect_called = detect_calls_n > 0
generate_cost = _as_cost(_first_present(data.get("cost"), budget.get("cost")))
detect_cost = _as_cost(_first_present(data.get("detect_cost"), nested.get("detect_cost")))
known = [item for item in (detect_cost, generate_cost) if item is not None]
total = sum(known) if known else None
if (detect_cost or 0) > 0 or (generate_cost or 0) > 0:
billed = "yes"
elif generate_requested and generate_cost is None:
billed = "unknown"
elif detect_called and detect_cost is None and not generate_called:
billed = "unknown"
else:
billed = "no"
parts: list[str] = []
if detect_called or detect_cost is not None:
if detect_cost is not None:
parts.append(f"Detect {_format_usd(detect_cost)}")
elif detect_called:
parts.append("Detect aufgerufen, Kosten unbekannt")
if generate_called and generate_cost is not None:
parts.append(f"Generate {_format_usd(generate_cost)}")
elif generate_called:
parts.append("Generate abgeschlossen, Kosten unbekannt")
elif generate_requested:
parts.append("Generate-Aufruf gesendet, Kosten unbekannt")
else:
parts.append("Generate nicht aufgerufen")
if billed == "yes":
note = "Beim Anbieter sind Kosten entstanden"
if parts:
note += ": " + "; ".join(parts) + "."
else:
note += "."
elif billed == "unknown":
note = "Ob beim Anbieter Kosten entstanden sind, ist unbekannt"
if parts:
note += " (" + "; ".join(parts) + ")."
else:
note += "."
else:
if detect_called or generate_requested or generate_called:
note = "Beim Anbieter sind für diesen Lauf keine Kosten ausgewiesen"
if parts:
note += " (" + "; ".join(parts) + ")."
else:
note += "."
else:
note = "Es wurde kein Provider aufgerufen. Es sind keine Kosten entstanden."
return {
"generate_called": generate_called,
"generate_requested": generate_requested,
"detect_called": detect_called,
"detect_calls": detect_calls_n,
"cost": generate_cost,
"detect_cost": detect_cost,
"total_cost": total,
"billed": billed,
"note": note,
}
def public_error_detail(exc) -> dict[str, Any]:
diagnostics = dict(getattr(exc, "diagnostics", None) or {})
report = public_cost_report(diagnostics)
if report and diagnostics.get("cost_report") is None:
diagnostics["cost_report"] = report
detail: dict[str, Any] = {
"code": getattr(exc, "code", None) or "error",
"message": getattr(exc, "message", None) or str(exc),
"cost_report": report,
}
http_status = diagnostics.get("http_status")
if http_status is not None:
detail["http_status"] = http_status
provider_message = diagnostics.get("provider_message")
if provider_message:
detail["provider_message"] = provider_message
if diagnostics:
detail["diagnostics"] = diagnostics
return detail
_LOG_FORBIDDEN_KEYS = frozenset(
{
"local_label",
@@ -227,6 +386,7 @@ def _raise_with_log(
diagnostics["purpose"] = purpose
if extra:
diagnostics.update({key: value for key, value in extra.items() if value is not None})
diagnostics["cost_report"] = public_cost_report(diagnostics)
raise PrivacyGatewayError(exc.code, exc.message, exc.status_code, diagnostics) from exc
@@ -835,6 +995,14 @@ def _fake_complete(purpose: str, rendered: str) -> str:
return '{"operation":"erleben_vertiefen","impulse":"' + impulse + '"}'
def _generate_timeout(purpose: str) -> float:
if purpose in JOURNAL_PURPOSES:
return 90
if purpose == "profile_review":
return 120
return 60
def complete_model(messages: list[dict], policy: dict[str, Any]) -> ChatResult:
config = generate_provider()
if not config:
@@ -851,7 +1019,7 @@ def complete_model(messages: list[dict], policy: dict[str, Any]) -> ChatResult:
return complete_chat(
config,
messages,
timeout=90 if (policy.get("purpose") in JOURNAL_PURPOSES) else 60,
timeout=_generate_timeout(policy.get("purpose") or ""),
max_tokens=policy.get("max_tokens"),
disable_context_compression=bool(policy.get("disable_context_compression")),
)
@@ -911,7 +1079,13 @@ def complete(request: GatewayRequest) -> GatewayResult:
exc.code,
user_detect_message(exc.code, exc.message),
exc.status_code,
{"log": events, "purpose": request.purpose, "generate_called": False, **detect_stats},
{
"log": events,
"purpose": request.purpose,
"generate_called": False,
"generate_requested": False,
**detect_stats,
},
) from exc
_log_event(
events,
@@ -945,6 +1119,7 @@ def complete(request: GatewayRequest) -> GatewayResult:
diagnostics.update(summary)
diagnostics.update({key: value for key, value in detect_stats.items() if value is not None})
diagnostics["generate_called"] = False
diagnostics["generate_requested"] = False
if request.purpose in JOURNAL_PURPOSES:
if budget is None:
_log_event(events, started, "budget", status="error", code="model_metadata_unknown")
@@ -1079,6 +1254,8 @@ def complete(request: GatewayRequest) -> GatewayResult:
purpose=request.purpose,
model=config.model if config else None,
)
diagnostics["generate_requested"] = True
request_trace["generate_requested"] = True
chat = complete_model([{"role": "user", "content": masked}], model_policy)
usages.append(chat.usage or {})
diagnostics["generate_called"] = True
@@ -1198,6 +1375,7 @@ def public_trace(trace: dict | None) -> dict | None:
"detect_ms": trace.get("detect_ms"),
"generate_ms": (trace.get("budget") or {}).get("generate_ms") if isinstance(trace.get("budget"), dict) else trace.get("generate_ms"),
"generate_called": trace.get("generate_called"),
"generate_requested": trace.get("generate_requested"),
"mapping_count": trace.get("mapping_count"),
"available_mapping_count": trace.get("available_mapping_count"),
"active_mapping_count": trace.get("active_mapping_count"),