From 655eabaa2f6a0543dc4b45a2e86b68dcdf1e0130 Mon Sep 17 00:00:00 2001 From: Abhyudaya Baiju Tharakan Date: Fri, 9 Oct 2026 03:37:23 +0530 Subject: [PATCH] feat(retention): add opt-in zero-content retention policy Resolve an immutable inherit/zero retention policy per default, verified key, route and request header behind CONTENT_RETENTION_ENABLED, default off. Zero requests bypass the chat cache and shadow sampling, keep roleplay state request-local and skip Knowledge memo and handoff writes. --- docs/zero-content-retention.md | 85 +++++++ package.json | 2 +- route_helpers.py | 4 +- routes/chat_cache.py | 4 + services/retention_policy.py | 94 ++++++++ services/shadow_eval_sampling.py | 21 +- tests/fixtures/secret_firewall_coverage.json | 1 + tests/test_zero_content_retention.py | 176 ++++++++++++++ tests/test_zero_content_retention_worker.mjs | 227 +++++++++++++++++++ worker/container-env.mjs | 2 + worker/cors-policy.mjs | 4 +- worker/knowledge/handoff-store.mjs | 9 +- worker/knowledge/memos.mjs | 10 +- worker/retention-policy.mjs | 68 ++++++ worker/roleplay/endpoint.mjs | 70 +++--- worker/roleplay/recovery.mjs | 13 +- worker/roleplay/session-storage.mjs | 65 ++++++ worker/roleplay/turn-trace.mjs | 14 +- 18 files changed, 823 insertions(+), 46 deletions(-) create mode 100644 docs/zero-content-retention.md create mode 100644 services/retention_policy.py create mode 100644 tests/test_zero_content_retention.py create mode 100644 tests/test_zero_content_retention_worker.mjs create mode 100644 worker/retention-policy.mjs diff --git a/docs/zero-content-retention.md b/docs/zero-content-retention.md new file mode 100644 index 00000000..0415a1e3 --- /dev/null +++ b/docs/zero-content-retention.md @@ -0,0 +1,85 @@ +# Zero-content retention + +`CONTENT_RETENTION_ENABLED` defaults to `false`. While off, the retention header +and policy JSON are ignored. Cache, sampling, roleplay, memo and handoff behavior +stays unchanged. An empty flag means off; an empty policy means `{}`. +Malformed settings disable these controls and log a warning once per setting, +without logging its value. Invalid configuration therefore does not provide a +retention guarantee: validate settings before enabling the feature. + +When enabled, `CONTENT_RETENTION_POLICY_JSON` accepts this shape: + +```json +{ + "default": "inherit", + "keys": { "verified-key-id-or-sha256": "zero" }, + "routes": { "/v1/chat/completions": "zero" } +} +``` + +Each value is `inherit` or `zero`; route matching is exact. Key selectors are +server-authenticated account IDs (username when no ID exists) or SHA-256 digests +of the authenticated presented key. Use a key digest for individual keys within +one account. Never put raw keys in the policy. The tightest default, key, route +and header wins. `X-MultiLLM-Retention: zero` tightens the policy; +`X-MultiLLM-Retention: inherit` and unknown header values cannot loosen it. + +For example, with the flag off, `X-MultiLLM-Cache: on` still caches an eligible +completion even if the caller sends `X-MultiLLM-Retention: zero`. With the flag +on and policy `{}`, that same retention header bypasses both cache reads and +writes, and bypasses shadow sample construction before a stream collector or +background queue can capture content. With a configured zero key or route, +sending `inherit` still bypasses retention. + +Zero roleplay turns use fresh request-local conversation state. Callers must +supply the conversation history needed for each turn. They cannot recover a +durable conversation, import a branch or use operator memory under that policy. +Turn responses expose `X-MultiLLM-Retention: zero` and +`X-MultiLLM-Roleplay-Recovery: unavailable`. Recovery returns HTTP 409 with +`recovery_unavailable`; memory operations return HTTP 409 with +`retention_forbidden`. Errors and completion bytes otherwise keep their existing +meaning. No replacement completion or new retry permission is introduced. + +Only numeric roleplay counters, bounded numeric model observations and hashed +request/model identities are written to a separate counter record. Content-free +traces exclude parameter receipts, retain at most 30 turns, and write separately +from existing traces. Zero turns neither populate the conversation cache nor +refresh the existing session deletion alarm. Old content, checkpoints, recovery +records and alarms are left in place; an already scheduled alarm can still run +under its original lifecycle. The feature does not scan or delete stored data. + +Knowledge memo lookup, embeddings, bundle construction and background writes are +disabled for zero requests. A derived handoff save returns HTTP 409 +`retention_forbidden` before parsing or SQL mutation. It returns no saved ID. +Explicit source-corpus ingestion remains separately authorized and is unaffected. + +The gateway must still hold and send content while serving a request, including +streaming and existing turn scheduling. Usage, cost, security and health counters +continue; provider calls can incur their normal cost. This is a prospective +gateway storage policy, not a provider-side retention agreement, secure memory +erasure, deletion API or prohibition on caller-authorized corpus storage. It does +not change provider prompt-cache settings or cover media storage and future +state/batch features; those features must adopt the same policy explicitly. + +## Where the policy applies + +- Flask resolves the policy after authentication and before cache and dispatch + hooks, and exposes it as `g.multillm_retention_policy`. The chat response cache + and shadow sampling check it before reading, writing or queueing content. +- The Worker resolves the policy only from the verified key identity and the + public request path. It ignores identity in caller payloads and caller-set + `X-MultiLLM-Retention-Key-ID`, `X-MultiLLM-Retention-Key-Hash` and + `X-MultiLLM-Retention-Route` headers, and sets those headers itself for + roleplay turns, operator recovery and memory requests. +- Knowledge retrieval uses a non-storing cache for zero requests. Handoff saves + are rejected before content is serialized into a Durable Object call. +- Set `CONTENT_RETENTION_ENABLED` and `CONTENT_RETENTION_POLICY_JSON` on both the + Worker and the Container. No routes, D1 tables or migrations are added. +- Browser clients can send `X-MultiLLM-Retention` and read + `X-MultiLLM-Retention` and `X-MultiLLM-Roleplay-Recovery`. + +Any feature that stores content must check the same policy before it builds a +record, queues content or persists it. + +Tests use fake providers and storage. They do not verify a deployment or +provider-side retention. diff --git a/package.json b/package.json index 42ee5f27..1ba3252c 100644 --- a/package.json +++ b/package.json @@ -9,7 +9,7 @@ "lint": "ruff check . --select E9,F63,F7,F82", "typecheck": "mypy --ignore-missing-imports --follow-imports=skip --disable-error-code import-untyped --disable-error-code var-annotated --disable-error-code arg-type --disable-error-code assignment --disable-error-code operator app.py routes services providers streaming", "test": "python -m pytest -q", - "test:worker": "node --test tests/test_cloudflare_worker.mjs tests/test_cascades_worker.mjs tests/test_cascades_dashboard.mjs tests/test_image_quality_worker.mjs tests/test_secret_scan_worker.mjs tests/test_secret_firewall_worker.mjs tests/test_secret_firewall_coverage_worker.mjs tests/test_roleplay_compaction_budget_worker.mjs tests/test_roleplay_compaction_model_worker.mjs tests/test_roleplay_stream_validation_worker.mjs tests/test_aihubmix_worker.mjs tests/test_gpt_image_moderation_worker.mjs tests/test_dashboard_scripts.mjs tests/test_operations_dashboard.mjs tests/test_opencode_reasoning_worker.mjs tests/test_opencode_thinking_worker.mjs tests/test_nanogpt_reasoning_worker.mjs tests/test_nanogpt_speed_routing_worker.mjs tests/test_sse_heartbeat_worker.mjs tests/test_roleplay_worker.mjs tests/test_roleplay_config_worker.mjs tests/test_roleplay_glm_failover_worker.mjs tests/test_roleplay_intelligence_worker.mjs tests/test_roleplay_memory_worker.mjs tests/test_roleplay_compatibility_worker.mjs tests/test_roleplay_history_reconciliation_worker.mjs tests/test_roleplay_output_contract_analysis.mjs tests/test_roleplay_output_contract_cleanup_worker.mjs tests/test_roleplay_output_contract_nonstream_worker.mjs tests/test_roleplay_output_contract_worker.mjs tests/test_roleplay_performance_worker.mjs tests/test_roleplay_quality_routing_worker.mjs tests/test_roleplay_reasoning_worker.mjs tests/test_roleplay_session_storage_worker.mjs tests/test_roleplay_transport_failure_worker.mjs tests/test_roleplay_unlimited_worker.mjs tests/test_roleplay_workbench_worker.mjs tests/test_roleplay_candidate_context_worker.mjs tests/test_roleplay_operator_worker.mjs tests/test_workbench_stream.mjs tests/test_intelligence_worker.mjs tests/test_intelligence_d1_worker.mjs tests/test_intelligence_auth_worker.mjs tests/test_intelligence_outbound_worker.mjs tests/test_intelligence_operator.mjs tests/test_control_users_worker.mjs tests/test_control_audit_worker.mjs tests/test_access_sso_worker.mjs tests/test_d1_schema_worker.mjs tests/test_shadow_eval_worker.mjs tests/test_auto_routes_worker.mjs tests/test_ai_outbound_worker.mjs tests/test_knowledge_*.mjs tests/test_control_state_worker.mjs tests/test_route_health_worker.mjs tests/test_gateway_mcp_worker.mjs tests/test_usage_ledger_worker.mjs tests/test_media_outbound_worker.mjs tests/test_media_files_worker.mjs tests/test_media_jobs_worker.mjs tests/test_tool_repair_worker.mjs tests/test_prometheus_worker.mjs tests/test_evaluation_noise_floor_worker.mjs tests/test_prompt_templates_worker.mjs tests/test_config_snapshots_worker.mjs", + "test:worker": "node --test tests/test_cloudflare_worker.mjs tests/test_cascades_worker.mjs tests/test_cascades_dashboard.mjs tests/test_image_quality_worker.mjs tests/test_secret_scan_worker.mjs tests/test_secret_firewall_worker.mjs tests/test_secret_firewall_coverage_worker.mjs tests/test_roleplay_compaction_budget_worker.mjs tests/test_roleplay_compaction_model_worker.mjs tests/test_roleplay_stream_validation_worker.mjs tests/test_aihubmix_worker.mjs tests/test_gpt_image_moderation_worker.mjs tests/test_dashboard_scripts.mjs tests/test_operations_dashboard.mjs tests/test_opencode_reasoning_worker.mjs tests/test_opencode_thinking_worker.mjs tests/test_nanogpt_reasoning_worker.mjs tests/test_nanogpt_speed_routing_worker.mjs tests/test_sse_heartbeat_worker.mjs tests/test_roleplay_worker.mjs tests/test_roleplay_config_worker.mjs tests/test_roleplay_glm_failover_worker.mjs tests/test_roleplay_intelligence_worker.mjs tests/test_roleplay_memory_worker.mjs tests/test_roleplay_compatibility_worker.mjs tests/test_roleplay_history_reconciliation_worker.mjs tests/test_roleplay_output_contract_analysis.mjs tests/test_roleplay_output_contract_cleanup_worker.mjs tests/test_roleplay_output_contract_nonstream_worker.mjs tests/test_roleplay_output_contract_worker.mjs tests/test_roleplay_performance_worker.mjs tests/test_roleplay_quality_routing_worker.mjs tests/test_roleplay_reasoning_worker.mjs tests/test_roleplay_session_storage_worker.mjs tests/test_roleplay_transport_failure_worker.mjs tests/test_roleplay_unlimited_worker.mjs tests/test_roleplay_workbench_worker.mjs tests/test_roleplay_candidate_context_worker.mjs tests/test_roleplay_operator_worker.mjs tests/test_workbench_stream.mjs tests/test_intelligence_worker.mjs tests/test_intelligence_d1_worker.mjs tests/test_intelligence_auth_worker.mjs tests/test_intelligence_outbound_worker.mjs tests/test_intelligence_operator.mjs tests/test_control_users_worker.mjs tests/test_control_audit_worker.mjs tests/test_access_sso_worker.mjs tests/test_d1_schema_worker.mjs tests/test_shadow_eval_worker.mjs tests/test_auto_routes_worker.mjs tests/test_ai_outbound_worker.mjs tests/test_knowledge_*.mjs tests/test_control_state_worker.mjs tests/test_route_health_worker.mjs tests/test_gateway_mcp_worker.mjs tests/test_usage_ledger_worker.mjs tests/test_media_outbound_worker.mjs tests/test_media_files_worker.mjs tests/test_media_jobs_worker.mjs tests/test_tool_repair_worker.mjs tests/test_prometheus_worker.mjs tests/test_evaluation_noise_floor_worker.mjs tests/test_prompt_templates_worker.mjs tests/test_config_snapshots_worker.mjs tests/test_zero_content_retention_worker.mjs", "db:migrate": "python scripts/validate_sqlite_schema.py --apply", "db:validate": "python scripts/validate_sqlite_schema.py", "security:secrets": "python scripts/check_static_secrets.py", diff --git a/route_helpers.py b/route_helpers.py index 3d8624c4..3c9e323d 100644 --- a/route_helpers.py +++ b/route_helpers.py @@ -26,7 +26,7 @@ CORS_ALLOWED_METHODS = "GET, POST, PUT, DELETE, PATCH, OPTIONS" CORS_DEFAULT_HEADERS = ( - "Authorization, Content-Type, Accept, Origin, X-Requested-With, X-MultiLLM-Tool-Repair, X-MultiLLM-Conversion-Report, " + "Authorization, Content-Type, Accept, Origin, X-Requested-With, X-MultiLLM-Tool-Repair, X-MultiLLM-Conversion-Report, X-MultiLLM-Retention, " "X-Api-Key, X-Goog-Api-Key, X-MultiLLM-Api-Key, Anthropic-Version, " "Anthropic-Beta, Anthropic-Dangerous-Direct-Browser-Access, " "Idempotency-Key, X-MultiLLM-Image-QA, X-MultiLLM-Cascade, OpenAI-Beta, OpenAI-Organization, " @@ -50,7 +50,7 @@ "X-MultiLLM-Auto-Route, X-MultiLLM-Auto-Selected-Model, " "X-MultiLLM-Auto-Attempts, X-MultiLLM-Auto-Selected-Priority, " "X-MultiLLM-Auto-Ordering, X-MultiLLM-Auto-Failover-Reasons, " - "X-MultiLLM-Cache, X-MultiLLM-Transport-Failure, X-MultiLLM-Token-Count, " + "X-MultiLLM-Cache, X-MultiLLM-Retention, X-MultiLLM-Roleplay-Recovery, X-MultiLLM-Transport-Failure, X-MultiLLM-Token-Count, " "X-MultiLLM-Latency-Ms, X-MultiLLM-Estimated-Cost-USD, " "X-MultiLLM-Cost-Basis, WWW-Authenticate, X-PAYMENT-RESPONSE, X-Poll-After, " "X-NanoGPT-Advisor-ID, X-NanoGPT-Data-Endpoint, " diff --git a/routes/chat_cache.py b/routes/chat_cache.py index d0276775..02e36db9 100644 --- a/routes/chat_cache.py +++ b/routes/chat_cache.py @@ -21,6 +21,7 @@ from route_helpers import request_api_key from services import cache_policy +from services.retention_policy import request_policy from services.cache_service import ResponseCache CACHE_HEADER = "X-MultiLLM-Cache" @@ -166,10 +167,13 @@ def cached_chat_completion(view): @wraps(view) def wrapper(*args, **kwargs): + retention = request_policy() mode, max_age = request_mode() settings = _settings() if mode is None or request.method != "POST": return view(*args, **kwargs) + if not retention.allows_content: + return _mark(view(*args, **kwargs), "bypass") payload = request.get_json(silent=True) principal = _principal() if not settings["enabled"] or principal is None or not request_is_cacheable(payload): diff --git a/services/retention_policy.py b/services/retention_policy.py new file mode 100644 index 00000000..7f044e61 --- /dev/null +++ b/services/retention_policy.py @@ -0,0 +1,94 @@ +"""Immutable, prospective retention decisions resolved after authentication.""" +from __future__ import annotations + +import hashlib +import json +import logging +import os +from dataclasses import dataclass +from functools import lru_cache +from typing import Mapping + +from flask import g, has_request_context, request + +HEADER = "X-MultiLLM-Retention" +_MODES = {"inherit", "zero"} +logger = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class RetentionPolicy: + mode: str = "inherit" + enabled: bool = False + revision: str = "legacy" + + @property + def allows_content(self) -> bool: + return not self.enabled or self.mode != "zero" + + +@lru_cache(maxsize=2) +def _warn_once(setting: str) -> None: + logger.warning("Invalid %s; content retention controls disabled", setting) + + +def _rules(value: object) -> bool: + if not isinstance(value, dict): + return False + return all(isinstance(key, str) and bool(key) and isinstance(mode, str) and mode in _MODES + for key, mode in value.items()) + + +def resolve_policy(env: Mapping[str, str] | None = None, *, key_id: str = "", + route: str = "", header: str = "", key_hash: str = "") -> RetentionPolicy: + """Tightest of default, authenticated key, exact route and caller opt-out.""" + env = os.environ if env is None else env + flag = str(env.get("CONTENT_RETENTION_ENABLED", "")).strip().lower() + if flag in {"", "0", "false", "no", "off"}: + return RetentionPolicy() + if flag not in {"1", "true", "yes", "on"}: + _warn_once("CONTENT_RETENTION_ENABLED") + return RetentionPolicy() + raw = env.get("CONTENT_RETENTION_POLICY_JSON", "").strip() or "{}" + try: + config = json.loads(raw) + if (not isinstance(config, dict) or set(config) - {"default", "keys", "routes"} + or not isinstance(config.get("default", "inherit"), str) + or config.get("default", "inherit") not in _MODES + or not _rules(config.get("keys", {})) or not _rules(config.get("routes", {}))): + raise ValueError("Invalid retention configuration") + except (ValueError, TypeError): + _warn_once("CONTENT_RETENTION_POLICY_JSON") + return RetentionPolicy() + modes = [config.get("default", "inherit"), config.get("routes", {}).get(route), + config.get("keys", {}).get(key_id), config.get("keys", {}).get(key_hash), + str(header).strip().lower()] + revision = hashlib.sha256(json.dumps(config, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + return RetentionPolicy("zero" if "zero" in modes else "inherit", True, revision) + + +def request_policy() -> RetentionPolicy: + """Snapshot once per request; stream callbacks must capture the returned value.""" + if not has_request_context(): + return RetentionPolicy() + captured = getattr(g, "multillm_content_retention", None) + if isinstance(captured, RetentionPolicy): + return captured + user = getattr(g, "authenticated_user", None) or {} + from route_helpers import request_api_key + key = request_api_key() if user else "" + key_hash = hashlib.sha256(key.encode()).hexdigest() if key else "" + policy = resolve_policy(key_id=str(user.get("id") or user.get("username") or ""), + key_hash=key_hash, route=request.path, header=request.headers.get(HEADER, "")) + g.multillm_content_retention = policy + if policy.enabled: + g.multillm_retention_policy = {"mode": policy.mode, "revision": policy.revision} + return policy + + +def init_retention_policy(app) -> None: + """Coordinator hook: call after authentication and before managed dispatch.""" + @app.before_request + def capture_retention(): + if getattr(g, "authenticated_user", None): + request_policy() diff --git a/services/shadow_eval_sampling.py b/services/shadow_eval_sampling.py index 439afff6..9be52827 100644 --- a/services/shadow_eval_sampling.py +++ b/services/shadow_eval_sampling.py @@ -11,6 +11,7 @@ from services.shadow_eval_contract import ANSWER_BYTES, REQUEST_BYTES, REQUEST_FIELDS, clean_usage, eligible, encoded, make_sample from services.shadow_eval_store import ShadowEvalStore +from services.retention_policy import RetentionPolicy, request_policy logger = logging.getLogger(__name__) _QUEUE = queue.Queue(maxsize=32) @@ -38,16 +39,16 @@ class CaptureOversize(ValueError): pass -def submit(sample): +def submit(sample, *, retention_policy=None): global _WORKER - if sample is None: + if sample is None or retention_policy is not None and not retention_policy.allows_content: return with _LOCK: if _WORKER is None or not _WORKER.is_alive(): _WORKER = threading.Thread(target=_persist, name="shadow-samples", daemon=True) _WORKER.start() try: - _QUEUE.put_nowait(sample) + _QUEUE.put_nowait((sample, retention_policy) if retention_policy is not None else sample) count("sampled") except queue.Full: count("skipped_queue_full") @@ -57,6 +58,10 @@ def _persist(): while True: sample = _QUEUE.get() try: + if isinstance(sample, tuple) and isinstance(sample[1], RetentionPolicy): + sample, retention = sample + if not retention.allows_content: + continue ShadowEvalStore.put(sample) except Exception as error: count("skipped_error") @@ -201,6 +206,9 @@ def sample_success(response, payload=None): if (response.status_code >= 400 or request.method != "POST" or getattr(g, "shadow_eval_internal", False) or getattr(g, "gateway_subrequest", False)): return response + retention = request_policy() + if not retention.allows_content: + return response payload = payload if payload is not None else request.get_json(silent=True) selected = _sampling_decision(payload) if selected is None: @@ -211,9 +219,14 @@ def sample_success(response, payload=None): model = response.headers.get("X-MultiLLM-Auto-Selected-Model") or getattr(g, "multillm_model", None) def capture(answer, selected, usage, finish_reason=None): + if not retention.allows_content: + return sample = make_sample(payload, user, route, answer, selected, (time.monotonic() - started) * 1000, usage, finish_reason=finish_reason, on_skip=count) - submit(sample) + if retention.enabled: + submit(sample, retention_policy=retention) + else: + submit(sample) if response.is_streamed: if response.mimetype == "text/event-stream": diff --git a/tests/fixtures/secret_firewall_coverage.json b/tests/fixtures/secret_firewall_coverage.json index ff0fe87b..375d0ae2 100644 --- a/tests/fixtures/secret_firewall_coverage.json +++ b/tests/fixtures/secret_firewall_coverage.json @@ -293,6 +293,7 @@ "worker/opencode/reasoning-response.mjs", "worker/prometheus.mjs", "worker/prompt-templates-d1.mjs", + "worker/retention-policy.mjs", "worker/roleplay/candidate-context.mjs", "worker/roleplay/capacity.mjs", "worker/roleplay/checkpoint.mjs", diff --git a/tests/test_zero_content_retention.py b/tests/test_zero_content_retention.py new file mode 100644 index 00000000..741b9e12 --- /dev/null +++ b/tests/test_zero_content_retention.py @@ -0,0 +1,176 @@ +"""Prospective retention barriers use immutable request context.""" +import json +import os +from unittest.mock import Mock, patch + +import pytest +from flask import Flask, Response, g + +from services.retention_policy import RetentionPolicy, resolve_policy, request_policy +from services import shadow_eval_sampling as sampling +from routes import chat_cache + + +@pytest.mark.parametrize("enabled", [None, "", "false", "no", "malformed"]) +def test_disabled_ignores_header_and_configuration(enabled): + env = {"CONTENT_RETENTION_POLICY_JSON": '{"default":"zero"}'} + if enabled is not None: + env["CONTENT_RETENTION_ENABLED"] = enabled + assert resolve_policy(env, key_id="test-key", route="/chat", header="zero").mode == "inherit" + + +def test_precedence_and_frozen_context(): + env = {"CONTENT_RETENTION_ENABLED": "true", "CONTENT_RETENTION_POLICY_JSON": json.dumps({ + "keys": {"test-key": "zero"}, "routes": {"/private": "zero"}})} + for key, route, header in [("test-key", "/chat", "inherit"), ("other", "/private", "inherit"), + ("other", "/chat", "zero")]: + policy = resolve_policy(env, key_id=key, route=route, header=header) + assert policy.mode == "zero" and policy.enabled + with pytest.raises(AttributeError): + policy.mode = "inherit" + assert resolve_policy(env, key_id="other", route="/chat", header="inherit").mode == "inherit" + + +@pytest.mark.parametrize("raw", ["{", "[]", '{"default":"bad"}', '{"keys":[]}', '{"routes":{"/chat":5}}']) +def test_invalid_config_is_off_without_logging_values(raw, caplog): + env = {"CONTENT_RETENTION_ENABLED": "true", "CONTENT_RETENTION_POLICY_JSON": raw} + assert not resolve_policy(env, header="zero").enabled + assert raw not in caplog.text + + +def app_fixture(monkeypatch): + app = Flask(__name__) + app.config["TESTING"] = True + sampling.init_shadow_sampling(app) + monkeypatch.setenv("RESPONSE_CACHE_POLICY_REVISION", "legacy") + monkeypatch.setenv("CONTENT_RETENTION_ENABLED", "true") + monkeypatch.setenv("CONTENT_RETENTION_POLICY_JSON", "{}") + chat_cache.clear() + upstream = Mock() + @app.before_request + def auth(): + g.authenticated_user = {"id": "test-key", "username": "reader", "shadow_eval_rate": 0.2} + @app.post("/v1/chat/completions") + @chat_cache.cached_chat_completion + def complete(): + upstream() + return Response(json.dumps({"choices": [{"message": {"content": "fixture answer"}, + "finish_reason": "stop"}], "usage": {"total_tokens": 3}}), mimetype="application/json", + headers={"X-MultiLLM-Auto-Selected-Model": "openai:fixture"}) + return app, upstream + + +def test_zero_bypasses_cache_and_sample_before_construction_preserves_old_entries(monkeypatch): + app, upstream = app_fixture(monkeypatch) + monkeypatch.setattr(sampling, "random", Mock(random=lambda: 0)) + submit = Mock() + monkeypatch.setattr(sampling, "submit", submit) + monkeypatch.setattr(sampling.random, "random", lambda: 0) + body = {"model": "auto:test", "temperature": 0, "messages": [{"role": "user", "content": "fixture prompt"}]} + headers = {"Authorization": "Bearer fixture-token", "X-MultiLLM-Cache": "on"} + client = app.test_client() + client.post("/v1/chat/completions", headers=headers, json=body) + old = dict(chat_cache._store._entries) + submit.reset_mock() + before = sampling.sampling_counts() + with patch.object(chat_cache._store, "get", side_effect=AssertionError("cache read")), \ + patch.object(chat_cache._store, "put", side_effect=AssertionError("cache write")), \ + patch.object(sampling, "make_sample", side_effect=AssertionError("content constructed")): + response = client.post("/v1/chat/completions", headers={**headers, "X-MultiLLM-Retention": "zero"}, json=body) + assert response.status_code == 200 and response.json["usage"] == {"total_tokens": 3} + assert response.headers["X-MultiLLM-Cache"] == "bypass" + assert chat_cache._store._entries == old + submit.assert_not_called() + assert sampling.sampling_counts() == before + assert upstream.call_count == 2 + + +def test_disabled_response_cache_and_sampling_unchanged(monkeypatch): + app, _ = app_fixture(monkeypatch) + monkeypatch.setenv("CONTENT_RETENTION_ENABLED", "false") + submit = Mock() + monkeypatch.setattr(sampling, "submit", submit) + monkeypatch.setattr(sampling.random, "random", lambda: 0) + body = {"model": "auto:test", "temperature": 0, "messages": [{"role": "user", "content": "fixture prompt"}]} + headers = {"Authorization": "Bearer fixture-token", "X-MultiLLM-Cache": "on", "X-MultiLLM-Retention": "zero"} + reply = app.test_client().post("/v1/chat/completions", headers=headers, json=body) + assert reply.headers["X-MultiLLM-Cache"] == "miss" + assert "X-MultiLLM-Retention" not in reply.headers + assert chat_cache._store.stats()["entries"] == 1 + submit.assert_called_once() + + +def test_zero_submit_does_not_start_thread_or_enqueue(): + with patch.object(sampling._QUEUE, "put_nowait") as enqueue, patch.object(sampling.threading, "Thread") as thread: + sampling.submit({"content": "fixture"}, retention_policy=RetentionPolicy("zero", True)) + enqueue.assert_not_called() + thread.assert_not_called() + + +def test_stream_callback_keeps_request_policy_after_context_and_config_change(monkeypatch): + app = Flask(__name__) + monkeypatch.setenv("CONTENT_RETENTION_ENABLED", "true") + monkeypatch.setenv("CONTENT_RETENTION_POLICY_JSON", "{}") + submitted = [] + monkeypatch.setattr(sampling, "submit", lambda sample, **kw: submitted.append((sample, kw))) + events = [b'data: {"choices":[{"delta":{"content":"fixture"},"finish_reason":"stop"}]}\n\n', b'data: [DONE]\n\n'] + with app.test_request_context("/v1/chat/completions", method="POST", json={"model":"auto:test", "messages":[{"content":"fixture"}]}): + g.authenticated_user = {"id":"test-key", "shadow_eval_rate":0.2} + g.shadow_eval_started = 0 + with patch.object(sampling.random, "random", return_value=0): + response = sampling.sample_success(Response(iter(events), mimetype="text/event-stream", + headers={"X-MultiLLM-Auto-Selected-Model":"openai:fixture"})) + policy = request_policy() + monkeypatch.setenv("CONTENT_RETENTION_POLICY_JSON", '{"default":"zero"}') + assert list(response.response) == events + assert len(submitted) == 1 and submitted[0][1]["retention_policy"] == policy + with app.test_request_context("/v1/chat/completions", method="POST", headers={"X-MultiLLM-Retention":"zero"}): + g.authenticated_user = {"id":"test-key", "shadow_eval_rate":0.2} + untouched = iter(events) + private = sampling.sample_success(Response(untouched, mimetype="text/event-stream")) + assert private.response is untouched + + +def test_background_persistence_uses_captured_policy(monkeypatch): + policy = RetentionPolicy("inherit", True) + monkeypatch.setattr(sampling, "_WORKER", Mock(is_alive=lambda: True)) + enqueue = Mock() + monkeypatch.setattr(sampling._QUEUE, "put_nowait", enqueue) + sampling.submit({"request": "fixture"}, retention_policy=policy) + queued = enqueue.call_args.args[0] + monkeypatch.setenv("CONTENT_RETENTION_POLICY_JSON", '{"default":"zero"}') + getter = Mock(side_effect=[queued, StopIteration]) + monkeypatch.setattr(sampling._QUEUE, "get", getter) + monkeypatch.setattr(sampling._QUEUE, "task_done", Mock()) + with patch.object(sampling.ShadowEvalStore, "put") as persisted, pytest.raises(StopIteration): + sampling._persist() + persisted.assert_called_once_with({"request": "fixture"}) + + +from tests.unified_api_test_case import UnifiedApiTestCase + + +class RegisteredRetentionTest(UnifiedApiTestCase): + def setUp(self): + for target in ("env_loader.load_runtime_env", "config.load_runtime_env"): + loader = patch(target) + loader.start() + self.addCleanup(loader.stop) + network = patch("requests.sessions.Session.request", side_effect=AssertionError("Unexpected network call")) + network.start() + self.addCleanup(network.stop) + super().setUp() + os.environ["CONTENT_RETENTION_ENABLED"] = "true" + os.environ["CONTENT_RETENTION_POLICY_JSON"] = '{"routes":{"/v1/chat/completions":"zero"}}' + os.environ["RESPONSE_CACHE_POLICY_REVISION"] = "legacy" + + def test_registered_route_cannot_loosen_server_retention_and_keeps_usage(self): + from tests.test_chat_cache import BODY, CACHED, chat_cache as cache_module, completion + cache = cache_module() + with patch.object(cache._store, "get", side_effect=AssertionError("cache read")), \ + patch.object(cache._store, "put", side_effect=AssertionError("cache write")), \ + patch("app.ProxyService.make_request", return_value=self._chat_response()) as upstream: + reply = self.client.post("/v1/chat/completions", json=BODY, + headers={**CACHED, "X-MultiLLM-Retention": "inherit"}) + assert reply.status_code == 200 and reply.headers["X-MultiLLM-Cache"] == "bypass" + assert upstream.call_count == 1 and reply.json["usage"] diff --git a/tests/test_zero_content_retention_worker.mjs b/tests/test_zero_content_retention_worker.mjs new file mode 100644 index 00000000..41e3bd70 --- /dev/null +++ b/tests/test_zero_content_retention_worker.mjs @@ -0,0 +1,227 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import { resolveRetentionPolicy, retentionAllowsContent, retentionKnowledgeOptions } from "../worker/retention-policy.mjs"; +import { createInitialRoleplayState, saveRoleplayState, createRetentionStateRepository } from "../worker/roleplay/session-storage.mjs"; +import { recoveryTemplate, preserveRecovery, handleRecoverySnapshot } from "../worker/roleplay/recovery.mjs"; +import { TurnTraceJournal } from "../worker/roleplay/turn-trace.mjs"; +import { memoSession } from "../worker/knowledge/memos.mjs"; +import { HandoffStore } from "../worker/knowledge/handoff-store.mjs"; +import { makeRoleplayEnv, completionResponse, handleRoleplayEdgeRequest, roleplayRequest, withGlobalFetch } from "./helpers/roleplay_fixture.mjs"; + +const enabled = { CONTENT_RETENTION_ENABLED: "true" }; +const zero = resolveRetentionPolicy(enabled, { header: "zero" }); +const normal = resolveRetentionPolicy({}); +const storage = () => ({ rows: new Map(), writes: [], async get(key) { return this.rows.get(key); }, + async put(key, value) { this.writes.push(structuredClone([key, value])); }, async delete() { assert.fail("deletion"); } }); + +test("disabled and invalid settings ignore header without retaining configuration values in logs", () => { + for (const flag of [undefined, "", "false", "nonsense"]) { + assert.equal(resolveRetentionPolicy({ CONTENT_RETENTION_ENABLED: flag }, { header: "zero" }).mode, "inherit"); + } + const warn = console.warn; const warnings = []; console.warn = value => warnings.push(value); + try { + for (const raw of ["{", "[]", '{"default":"bad"}', '{"keys":[]}', '{"routes":{"/chat":5}}']) { + assert.equal(resolveRetentionPolicy({ ...enabled, CONTENT_RETENTION_POLICY_JSON: raw }, { header: "zero" }).enabled, false); + } + } finally { console.warn = warn; } + assert.ok(warnings.length <= 1); +}); + +test("key and route restrictions cannot be loosened and captured policy is immutable", () => { + const env = { ...enabled, CONTENT_RETENTION_POLICY_JSON: JSON.stringify({ keys: { reader: "zero" }, routes: { "/private": "zero" } }) }; + for (const identity of [{ keyId: "reader", route: "/chat" }, { keyId: "other", route: "/private" }]) { + assert.equal(resolveRetentionPolicy(env, { ...identity, header: "inherit" }).mode, "zero"); + } + assert.equal(retentionAllowsContent(zero), false); + assert.equal(retentionAllowsContent(normal), true); + assert.throws(() => { zero.mode = "inherit"; }, TypeError); +}); + +test("zero state writes contain only counters and preserve previous content without using the content cache", async () => { + const s = storage(); s.rows.set("roleplay-messages", [{ content: "old content" }]); + const state = { ...createInitialRoleplayState(), messages: [{ content: "private prompt" }], memory: "private memory", profile: { name: "private name" }, turns: 4 }; + const repo = createRetentionStateRepository(s, { load() { assert.fail("content cache"); }, save() { assert.fail("content cache"); } }, zero); + assert.deepEqual((await repo.load()).messages, []); + await repo.save(state, { private: "private trace" }); + await saveRoleplayState(s, state, null, { private: "private metadata" }, zero); + assert.equal(s.rows.get("roleplay-messages")[0].content, "old content"); + assert.doesNotMatch(JSON.stringify(s.writes), /private|old content/); + assert.match(JSON.stringify(s.writes), /"turns":4/); +}); + +test("zero retains numeric model and security counts under hashed identities", async () => { + const s = storage(); + s.put = async (key, value) => { s.writes.push([key, structuredClone(value)]); s.rows.set(key, structuredClone(value)); }; + const candidates = [{ key: "private candidate identity", provider: "fixture", model: "fixture-model", family: "fixture" }]; + const repo = createRetentionStateRepository(s, null, zero, candidates); + await repo.save({ ...createInitialRoleplayState(), stats: { "private candidate identity": { + attempts: 4, successes: 3, failures: 1, completionTokens: 10, consecutiveFailures: 1, + cooldownUntil: 1000, private: "private response", ttfbSamplesMs: [5, "private sample"], + } } }); + assert.doesNotMatch(JSON.stringify(s.writes), /private|completionTokens/); + assert.match(JSON.stringify(s.writes), /"attempts":4/); + const loaded = await repo.load(); + assert.equal(loaded.stats[candidates[0].key].attempts, 4); + assert.deepEqual(loaded.stats[candidates[0].key].ttfbSamplesMs, [5]); +}); + +test("zero trace keeps numeric metrics but excludes parameter content before queuing", async () => { + const s = storage(); const journal = new TurnTraceJournal(s); await journal.ready; + const trace = journal.begin(zero); + trace.selected({ provider: "fixture", model: "fixture-model" }, { private: "private parameters" }); + trace.metrics({ completionTokens: 3 }); + await trace.finish(true, "completed", () => assert.fail("content persistence callback")); + assert.doesNotMatch(JSON.stringify(s.writes), /private/); + assert.doesNotMatch(JSON.stringify(s.writes), /fixture-model|"provider"|"model"/); + assert.match(JSON.stringify(s.writes), /completionTokens/); +}); + +test("zero recovery rejects before reads, construction or writes and preserves old snapshots", async () => { + const s = storage(); s.rows.set("operator_recovery_v1", { partial: "old content" }); + assert.equal(recoveryTemplate({ recovery_enabled: true }, [{ content: "private prompt" }], zero), null); + await preserveRecovery(s, { private: "private template" }, { success: false, assistant: "private answer" }, "fixture", zero); + const response = await handleRecoverySnapshot({ ctx: { storage: s } }, new Request("https://roleplay.internal/operator/recovery", { method: "POST" }), zero); + assert.equal(response.status, 409); + assert.equal((await response.json()).error.code, "recovery_unavailable"); + assert.equal(s.writes.length, 0); + assert.equal(s.rows.get("operator_recovery_v1").partial, "old content"); +}); + +test("zero Knowledge blocks memo construction, embedding and queue registration; usage survives", async () => { + const usage = [{ provider: "fixture", bound_units: 1 }]; + const options = { retentionPolicy: zero, memos: { call() { assert.fail("memo persistence"); } }, + embed() { assert.fail("embedding"); }, waitUntil() { assert.fail("queued content"); } }; + const session = memoSession(enabled, { call() { assert.fail("validation"); } }, { query: "private prompt" }, {}, options, performance.now(), usage); + assert.deepEqual(await session.lookup(), {}); + await session.write({ status: "ok", excerpts: [{ text: "private answer" }] }); + await session.storeBundle({ private: "private answer" }); + assert.deepEqual(session.finish({}).usage, usage); + const isolated = retentionKnowledgeOptions(zero, options); + assert.equal(await isolated.cache.match("fixture"), undefined); + await isolated.cache.put("fixture", new Response("private answer")); + assert.equal(retentionKnowledgeOptions(normal, options), options); +}); + +test("zero handoff refuses before parse or SQL mutation without fake saved IDs", () => { + const s = { sql: { exec() { return []; } }, transactionSync() { assert.fail("persistence"); } }; + const store = new HandoffStore(s); + assert.throws(() => store.call("save", { private: "private input" }, Date.now(), zero), error => error.code === "retention_forbidden"); + assert.throws(() => store.save({ private: "private input" }, Date.now(), zero), error => error.code === "retention_forbidden"); +}); + +const turn = { model: "roleplay:auto", messages: [{ role: "user", content: "private scene" }], + memory: { mode: "off" }, history_mode: "replace", recovery_enabled: true, stream: false }; + +test("native public roleplay global zero preserves old records and exposes unavailable recovery", async () => { + const f = makeRoleplayEnv({ ...enabled, CONTENT_RETENTION_POLICY_JSON: '{"default":"zero"}' }); + const reply = await withGlobalFetch(async () => completionResponse("fixture", "private reply"), + () => handleRoleplayEdgeRequest(roleplayRequest(turn), f.env)); + assert.equal(reply.status, 200); + assert.equal(reply.headers.get("X-MultiLLM-Retention"), "zero"); + assert.equal(reply.headers.get("X-MultiLLM-Roleplay-Recovery"), "unavailable"); + assert.match(await reply.text(), /private reply/); + await f.waitForBackgroundWork(); + const entry = [...f.storageBySession.values()][0]; + assert.equal(entry.instance.stateRepository.loaded, false); + assert.doesNotMatch(JSON.stringify([...entry.storage.values]), /private scene|private reply/); + assert.equal(entry.storage.operations.setAlarm, 0); +}); + +test("internal zero header survives streaming completion after config changes without persisting content", async () => { + const f = makeRoleplayEnv(enabled); + const stub = f.env.ROLEPLAY_SESSION.getByName("fixture"); + const entry = f.storageBySession.get("fixture"); + entry.storage.values.set("roleplay-messages", [{ role: "user", content: "old content" }]); + entry.storage.values.set("operator_recovery_v1", { partial: "old partial" }); + const frames = 'data: {"choices":[{"delta":{"content":"private reply"}}]}\n\n' + + 'data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"completion_tokens":3}}\n\n' + + 'data: [DONE]\n\n'; + const reply = await withGlobalFetch(async () => new Response(frames, { headers: { "content-type": "text/event-stream" } }), + () => stub.fetch(new Request("https://roleplay.internal/turn", { method: "POST", + headers: { "X-MultiLLM-Retention": "zero", "Idempotency-Key": "private request identity" }, + body: JSON.stringify({ ...turn, stream: true }) }))); + assert.equal(reply.status, 200); + f.env.CONTENT_RETENTION_ENABLED = "false"; + assert.match(await reply.text(), /private reply/); + await f.waitForBackgroundWork(); + assert.deepEqual(entry.storage.values.get("roleplay-messages"), [{ role: "user", content: "old content" }]); + assert.equal(entry.storage.values.get("operator_recovery_v1").partial, "old partial"); + const retained = [...entry.storage.values].filter(([key]) => key !== "roleplay-messages" && key !== "operator_recovery_v1"); + assert.doesNotMatch(JSON.stringify(retained), /private scene|private reply|private request identity/); + assert.match(JSON.stringify(retained), /completionTokens/); + assert.equal(entry.instance.stateRepository.loaded, false); +}); + +test("zero provider failure and aborted requests never make conversation or recovery writes", async () => { + const f = makeRoleplayEnv({ ...enabled, CONTENT_RETENTION_POLICY_JSON: '{"default":"zero"}' }); + const stub = f.env.ROLEPLAY_SESSION.getByName("fixture"); + const response = await withGlobalFetch(async () => Response.json({ error: "private failure" }, { status: 400 }), + () => stub.fetch(new Request("https://roleplay.internal/turn", { method: "POST", body: JSON.stringify(turn) }))); + assert.equal(response.status, 400); + const controller = new AbortController(); controller.abort(); + const cancelled = await stub.fetch(new Request("https://roleplay.internal/turn", { + method: "POST", body: JSON.stringify(turn), signal: controller.signal })); + assert.equal(cancelled.status, 499); + await f.waitForBackgroundWork(); + assert.doesNotMatch(JSON.stringify([...f.storageBySession.get("fixture").storage.values]), /private scene|private failure/); +}); + +test("queued normal and zero turns keep independent policies and conversation state", async () => { + const f = makeRoleplayEnv(enabled); + const stub = f.env.ROLEPLAY_SESSION.getByName("fixture"); + const seen = []; + await withGlobalFetch(async (_url, init) => { + const payload = JSON.parse(init.body); seen.push(payload.messages); + if (payload.stream) return new Response('data: {"choices":[{"delta":{"content":"private reply"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n', + { headers: { "content-type": "text/event-stream" } }); + return completionResponse("fixture", "ordinary reply"); + }, async () => { + const privateReply = await stub.fetch(new Request("https://roleplay.internal/turn", { method: "POST", + headers: { "X-MultiLLM-Retention": "zero" }, body: JSON.stringify({ ...turn, stream: true }) })); + const ordinary = stub.fetch(new Request("https://roleplay.internal/turn", { method: "POST", + headers: { "X-MultiLLM-Retention": "inherit" }, body: JSON.stringify({ ...turn, memory: { mode: "auto" }, + messages: [{ role: "user", content: "ordinary scene" }] }) })); + await privateReply.text(); + const reply = await ordinary; + assert.equal(reply.headers.get("X-MultiLLM-Retention"), null); + assert.equal(reply.status, 200); + await reply.text(); + await f.waitForBackgroundWork(); + }); + assert.equal(seen.length, 2); + assert.doesNotMatch(JSON.stringify(seen[1]), /private scene|private reply/); + const stored = [...f.storageBySession.get("fixture").storage.values]; + assert.doesNotMatch(JSON.stringify(stored), /private scene|private reply/); + assert.match(JSON.stringify(stored), /ordinary scene|ordinary reply/); +}); + +test("zero repeated request identities remain hashed and cannot silently replay", async () => { + const f = makeRoleplayEnv({ ...enabled, CONTENT_RETENTION_POLICY_JSON: '{"default":"zero"}' }); + const stub = f.env.ROLEPLAY_SESSION.getByName("fixture"); + let dispatched = 0; + const request = () => new Request("https://roleplay.internal/turn", { method: "POST", + headers: { "Idempotency-Key": "private identity" }, body: JSON.stringify(turn) }); + await withGlobalFetch(async () => { dispatched++; return completionResponse("fixture"); }, async () => { + assert.equal((await stub.fetch(request())).status, 200); + assert.equal((await stub.fetch(request())).status, 409); + }); + assert.equal(dispatched, 1); + assert.doesNotMatch(JSON.stringify([...f.storageBySession.get("fixture").storage.values]), /private identity|private scene/); +}); + +test("zero operator memory rejects before storage and disabled requests keep durable state", async () => { + const f = makeRoleplayEnv({ ...enabled, CONTENT_RETENTION_POLICY_JSON: '{"default":"zero"}' }); + const stub = f.env.ROLEPLAY_SESSION.getByName("fixture"); + const blocked = await stub.fetch(new Request("https://roleplay.internal/operator/import-branch", { + method: "POST", body: JSON.stringify({ content: "private branch" }) })); + assert.equal(blocked.status, 409); + assert.equal(f.storageBySession.get("fixture").storage.operations.put, 0); + f.env.CONTENT_RETENTION_ENABLED = "false"; + const reply = await withGlobalFetch(async () => completionResponse("fixture", "ordinary reply"), + () => stub.fetch(new Request("https://roleplay.internal/turn", { method: "POST", headers: { "X-MultiLLM-Retention": "zero" }, + body: JSON.stringify({ ...turn, memory: { mode: "auto" }, messages: [{ role: "user", content: "ordinary scene" }] }) }))); + assert.equal(reply.status, 200); + assert.equal(reply.headers.get("X-MultiLLM-Retention"), null); + assert.equal(reply.headers.get("X-MultiLLM-Roleplay-Recovery"), null); + assert.match(JSON.stringify([...f.storageBySession.get("fixture").storage.values]), /ordinary scene|ordinary reply/); +}); diff --git a/worker/container-env.mjs b/worker/container-env.mjs index f678771b..38fb728d 100644 --- a/worker/container-env.mjs +++ b/worker/container-env.mjs @@ -1,6 +1,8 @@ const DIRECT_ENV_KEYS = [ "PROMETHEUS_ENABLED", "SECRET_SCAN_DEFAULT", + "CONTENT_RETENTION_ENABLED", + "CONTENT_RETENTION_POLICY_JSON", "UPSTREAM_DEFAULT_USER_AGENT", "UPSTREAM_DEFAULT_ORIGINATOR", "A6API_API_KEY", diff --git a/worker/cors-policy.mjs b/worker/cors-policy.mjs index 5d773e55..cd0b64bc 100644 --- a/worker/cors-policy.mjs +++ b/worker/cors-policy.mjs @@ -1,6 +1,6 @@ export const CORS_ALLOWED_METHODS = "GET, POST, PUT, DELETE, PATCH, OPTIONS"; export const CORS_DEFAULT_HEADERS = - "X-MultiLLM-Tool-Repair, X-MultiLLM-Image-QA, X-MultiLLM-Cascade, X-MultiLLM-Conversion-Report, Authorization, X-Api-Key, X-Goog-Api-Key, X-MultiLLM-Api-Key, X-Roleplay-Session-ID, Anthropic-Version, Anthropic-Beta, Anthropic-Dangerous-Direct-Browser-Access, Content-Type, Accept, Origin, X-Requested-With, OpenAI-Beta, OpenAI-Organization, OpenAI-Project, Idempotency-Key, Moderation, Moderation-Model, Redaction, X-Client-Request-ID, X-App-Name, X-Billing-Mode, X-BYOK-Provider, X-Encryption-Key, X-Encryption-Passphrase, X-Fal-Object-Lifecycle-Preference, X-PAYMENT, X-Prompt-Caching-Cut-After, X-Provider, X-Team-ID, X-Use-BYOK, x-x402"; + "X-MultiLLM-Tool-Repair, X-MultiLLM-Image-QA, X-MultiLLM-Cascade, X-MultiLLM-Conversion-Report, X-MultiLLM-Retention, Authorization, X-Api-Key, X-Goog-Api-Key, X-MultiLLM-Api-Key, X-Roleplay-Session-ID, Anthropic-Version, Anthropic-Beta, Anthropic-Dangerous-Direct-Browser-Access, Content-Type, Accept, Origin, X-Requested-With, OpenAI-Beta, OpenAI-Organization, OpenAI-Project, Idempotency-Key, Moderation, Moderation-Model, Redaction, X-Client-Request-ID, X-App-Name, X-Billing-Mode, X-BYOK-Provider, X-Encryption-Key, X-Encryption-Passphrase, X-Fal-Object-Lifecycle-Preference, X-PAYMENT, X-Prompt-Caching-Cut-After, X-Provider, X-Team-ID, X-Use-BYOK, x-x402"; export const CORS_EXPOSE_HEADERS = - "X-MultiLLM-Secret-Scan, " + + "X-MultiLLM-Secret-Scan, X-MultiLLM-Retention, X-MultiLLM-Roleplay-Recovery, " + "X-MultiLLM-Tool-Repair, X-MultiLLM-Image-QA, X-MultiLLM-Cascade, X-MultiLLM-Conversion-Fidelity, X-MultiLLM-Conversion-Fields, Retry-After, X-Request-ID, X-MultiLLM-Optimization, X-MultiLLM-Optimization-Mode, X-MultiLLM-Estimated-Input-Before, X-MultiLLM-Estimated-Input-After, X-MultiLLM-Image-Prompts-Compacted, X-MultiLLM-Messages-Summarized, X-MultiLLM-Optimization-Target-Met, X-MultiLLM-Summary, X-MultiLLM-Optimization-Cache-Hits, X-MultiLLM-Optimization-Cache-Misses, X-MultiLLM-Prompt-Cache, X-MultiLLM-Prompt-Cache-Mode, X-MultiLLM-Prompt-Cache-Estimated-Tokens, X-MultiLLM-Provider, X-MultiLLM-Model, X-MultiLLM-Credential-Attempts, X-MultiLLM-Route-Decision, X-MultiLLM-Circuit-State, X-MultiLLM-Auto-Route, X-MultiLLM-Auto-Selected-Model, X-MultiLLM-Auto-Attempts, X-MultiLLM-Auto-Selected-Priority, X-MultiLLM-Auto-Ordering, X-MultiLLM-Auto-Failover-Reasons, X-MultiLLM-Cache, X-MultiLLM-Transport-Failure, X-MultiLLM-Token-Count, X-MultiLLM-Latency-Ms, X-MultiLLM-Estimated-Cost-USD, X-MultiLLM-Cost-Basis, X-MultiLLM-Reasoning-Normalized, X-Roleplay-Session-ID, X-Roleplay-Trace-ID, X-Roleplay-Session-Source, X-Roleplay-Provider, X-Roleplay-Model, X-Roleplay-Selection, X-Roleplay-Memory, X-Roleplay-Estimated-Input-Tokens, X-Roleplay-Max-Output-Tokens, X-Roleplay-Fallback-Count, X-Roleplay-State-Cache, X-Roleplay-Credential-Check, Server-Timing, WWW-Authenticate, X-PAYMENT-RESPONSE, X-Poll-After, X-NanoGPT-Advisor-ID, X-NanoGPT-Data-Endpoint, X-NanoGPT-Direct-Endpoint, X-NanoGPT-Inline-Moderation-Cost-USD, X-NanoGPT-Inline-Moderation-Flagged, X-NanoGPT-Inline-Moderation-Model"; diff --git a/worker/knowledge/handoff-store.mjs b/worker/knowledge/handoff-store.mjs index 6c538e70..bd3e6848 100644 --- a/worker/knowledge/handoff-store.mjs +++ b/worker/knowledge/handoff-store.mjs @@ -1,4 +1,5 @@ import { fail } from "./contracts.mjs"; +import { retentionAllowsContent } from "../retention-policy.mjs"; import { HANDOFF_BYTES, handoffBytes, parseHandoff, renderHandoff } from "./handoff-contracts.mjs"; export const HANDOFF_PROJECT_LIMIT = 50; @@ -20,7 +21,8 @@ export class HandoffStore { rows(query, ...args) { return [...this.sql.exec(query, ...args)]; } - save(parsed, now) { + save(parsed, now, retentionPolicy = null) { + if (!retentionAllowsContent(retentionPolicy)) fail("retention_forbidden", "Handoff content cannot be saved under zero retention.", 409); const { ttl_days, ...content } = parsed; const record = { id: crypto.randomUUID(), ...content, created_at: new Date(now).toISOString(), expires_at: new Date(now + ttl_days * 86400000).toISOString() }; @@ -58,9 +60,10 @@ export class HandoffStore { return { handoffs, trust: "operator" }; } - call(operation, payload, now = Date.now()) { + call(operation, payload, now = Date.now(), retentionPolicy = null) { + if (operation === "save" && !retentionAllowsContent(retentionPolicy)) fail("retention_forbidden", "Handoff content cannot be saved under zero retention.", 409); const parsed = parseHandoff(operation, payload); - if (operation === "save") return this.save(parsed, now); + if (operation === "save") return this.save(parsed, now, retentionPolicy); if (operation === "get") return this.get(parsed, new Date(now).toISOString()); if (operation === "list") return this.list(parsed, new Date(now).toISOString()); const deleted = this.rows("SELECT id FROM handoffs WHERE id = ? LIMIT 1", parsed.id).length > 0; diff --git a/worker/knowledge/memos.mjs b/worker/knowledge/memos.mjs index 61308178..3aeb6797 100644 --- a/worker/knowledge/memos.mjs +++ b/worker/knowledge/memos.mjs @@ -1,4 +1,5 @@ import { fail } from "./contracts.mjs"; +import { resolveRetentionPolicy, retentionAllowsContent } from "../retention-policy.mjs"; import { digest } from "./evidence.mjs"; import { memoKey, memoQueryNorm, memoSecretQuery, quantizeEmbedding, MEMO_BUNDLE_BYTES } from "./memo-store.mjs"; @@ -34,6 +35,11 @@ export function getMemos(env) { class MemoSession { constructor(env, authority, request, policy, options, started, usage) { Object.assign(this, { env, authority, request, policy, options, started, usage }); + this.retentionPolicy = options.retentionPolicy ?? resolveRetentionPolicy(env, { + keyId: options.retentionKeyId, keyHash: options.retentionKeyHash, + route: options.retentionRoute, header: options.retentionHeader, + }); + if (!retentionAllowsContent(this.retentionPolicy)) { this.enabled = false; return; } try { this.store = options.memos ?? getMemos(env); } catch { this.store = null; } this.enabled = this.store && !memoSecretQuery(request.query); @@ -50,6 +56,7 @@ class MemoSession { } async embed() { + if (!retentionAllowsContent(this.retentionPolicy)) return null; const { env, options, request, usage } = this; if (!options.embed && !env.KNOWLEDGE_SEARCH_AI?.run) return null; // Background completions must not mutate usage already returned to the caller. @@ -141,6 +148,7 @@ class MemoSession { } async storeBundle(bundle) { + if (!retentionAllowsContent(this.retentionPolicy)) return; const deadline = Math.min(this.deadline(MEMO_TIMEOUT_MS), this.options.waitUntil ? Infinity : this.options.memoWriteDeadlineAt ?? Infinity); if (deadline <= performance.now()) return; @@ -166,7 +174,7 @@ class MemoSession { } async write(bundle, failed) { - if (!this.enabled || failed || this.exact === "off" && this.semantic === "off" + if (!retentionAllowsContent(this.retentionPolicy) || !this.enabled || failed || this.exact === "off" && this.semantic === "off" || !["ok", "partial"].includes(bundle.status) || !bundle.excerpts?.length) return; // Validation, embedding and storage all belong to the background task. const write = Promise.resolve().then(() => this.storeBundle(bundle)).catch(() => {}); diff --git a/worker/retention-policy.mjs b/worker/retention-policy.mjs new file mode 100644 index 00000000..c5f9ce4c --- /dev/null +++ b/worker/retention-policy.mjs @@ -0,0 +1,68 @@ +// Immutable policy snapshots belong to requests, including their deferred callbacks. +export const RETENTION_HEADER = "X-MultiLLM-Retention"; +const OFF = Object.freeze({ mode: "inherit", enabled: false }); +const MODES = new Set(["inherit", "zero"]); +const warned = new Set(); + +function warnOnce(setting) { + if (warned.has(setting)) return; + warned.add(setting); + console.warn(`Invalid ${setting}; content retention controls disabled`); +} + +function rules(value) { + return value && typeof value === "object" && !Array.isArray(value) + && Object.entries(value).every(([key, mode]) => key.length && MODES.has(mode)); +} + +export function resolveRetentionPolicy(env = {}, { keyId = "", keyHash = "", route = "", header = "" } = {}) { + const flag = String(env.CONTENT_RETENTION_ENABLED ?? "").trim().toLowerCase(); + if (["", "0", "false", "no", "off"].includes(flag)) return OFF; + if (!["1", "true", "yes", "on"].includes(flag)) { warnOnce("CONTENT_RETENTION_ENABLED"); return OFF; } + let config; + try { + config = JSON.parse(String(env.CONTENT_RETENTION_POLICY_JSON ?? "").trim() || "{}"); + if (!config || typeof config !== "object" || Array.isArray(config) + || Object.keys(config).some(key => !["default", "keys", "routes"].includes(key)) + || !MODES.has(Object.hasOwn(config, "default") ? config.default : "inherit") + || !rules(Object.hasOwn(config, "keys") ? config.keys : {}) + || !rules(Object.hasOwn(config, "routes") ? config.routes : {})) throw new Error("invalid_policy"); + } catch { warnOnce("CONTENT_RETENTION_POLICY_JSON"); return OFF; } + const modes = [config.default, config.keys?.[keyId], config.keys?.[keyHash], config.routes?.[route], String(header).trim().toLowerCase()]; + return Object.freeze({ mode: modes.includes("zero") ? "zero" : "inherit", enabled: true }); +} + +export function retentionAllowsContent(policy) { + return !policy?.enabled || policy.mode !== "zero"; +} + +export async function retentionRequestId(value) { + if (!value) return ""; + const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)); + return Array.from(new Uint8Array(bytes), byte => byte.toString(16).padStart(2, "0")).join(""); +} + +// Only the authenticated edge may set identity headers on an internal DO request. +export function resolveRoleplayRetention(env, request) { + return resolveRetentionPolicy(env, { + keyId: request.headers.get("X-MultiLLM-Retention-Key-ID") ?? "", + keyHash: request.headers.get("X-MultiLLM-Retention-Key-Hash") ?? "", + route: request.headers.get("X-MultiLLM-Retention-Route") ?? new URL(request.url).pathname, + header: request.headers.get(RETENTION_HEADER) ?? "", + }); +} + +export function retentionResponse(response, policy) { + if (!retentionAllowsContent(policy)) { + response.headers.set(RETENTION_HEADER, "zero"); + response.headers.set("X-MultiLLM-Roleplay-Recovery", "unavailable"); + } + return response; +} + +const NO_CONTENT_CACHE = Object.freeze({ async match() { return undefined; }, async put() {} }); +export function retentionKnowledgeOptions(policy, options = {}) { + if (!policy?.enabled) return options; + return { ...options, retentionPolicy: policy, + ...(!retentionAllowsContent(policy) ? { cache: NO_CONTENT_CACHE } : {}) }; +} diff --git a/worker/roleplay/endpoint.mjs b/worker/roleplay/endpoint.mjs index 20ca1f5e..7c25eadd 100644 --- a/worker/roleplay/endpoint.mjs +++ b/worker/roleplay/endpoint.mjs @@ -3,7 +3,10 @@ import { SECRET_SCAN_HEADER } from "../secret-firewall.mjs"; import { clientContextHeaders } from "../client-headers.mjs"; import { TurnTraceJournal } from "./turn-trace.mjs"; import { handleOperatorMemory } from "./operator-memory.mjs"; -import { recoveryTemplate, preserveRecovery, handleRecoverySnapshot } from "./recovery.mjs"; +import { + recoveryTemplate, preserveRecovery, handleRecoverySnapshot, resolveRoleplayRetention, + retentionResponse, retentionRequestId, retentionAllowsContent, createRetentionStateRepository, +} from "./recovery.mjs"; import { parseRoutingPolicy, filterRoutingCandidates, parameterReceipt } from "./routing-policy.mjs"; import { @@ -114,17 +117,20 @@ export class RoleplaySession extends DurableObject { } async fetch(request) { + const retention = resolveRoleplayRetention(this.env, request); await this.traces.ready; const pathname = new URL(request.url).pathname; if (pathname === "/operator/timeline" && request.method === "GET") { return jsonResponse(this.traces.snapshot()); } if (["/operator/memory", "/operator/import-branch"].includes(pathname)) { + if (!retentionAllowsContent(retention)) return retentionResponse( + errorResponse("Durable conversation memory is unavailable under zero retention", 409, "retention_forbidden"), retention); return handleOperatorMemory(this, request, pathname.split("/").pop()); } - if (pathname === "/operator/recovery" && request.method === "POST") return handleRecoverySnapshot(this, request); + if (pathname === "/operator/recovery" && request.method === "POST") return handleRecoverySnapshot(this, request, retention); if (pathname === "/metrics" && request.method === "GET") { - const state = await this.stateRepository.load(); + const state = await createRetentionStateRepository(this.ctx.storage, this.stateRepository, retention, this.configuredCandidates).load(); return jsonResponse( buildRoleplaySessionMetrics(state, { pendingTurns: this.pendingTurns, @@ -134,19 +140,19 @@ export class RoleplaySession extends DurableObject { if (pathname !== "/turn" || request.method !== "POST") { return errorResponse("Method not allowed", 405, "method_not_allowed"); } - this.refreshSessionAlarm(); - return this.enqueueTurn(request, this.settings); + if (retentionAllowsContent(retention)) this.refreshSessionAlarm(); + return retentionResponse(await this.enqueueTurn(request, this.settings, retention), retention); } - async enqueueTurn(request, settings) { - const trace = this.traces.begin(); + async enqueueTurn(request, settings, retention = resolveRoleplayRetention(this.env, request)) { + const trace = this.traces.begin(retention); try { return await this.turnQueue.run( request, settings, async (turnRequest, queueMs) => { trace.phase("preparing"); trace.metrics({ queueMs }); - const result = await this.handleTurn(turnRequest, settings, queueMs, trace); + const result = await this.handleTurn(turnRequest, settings, queueMs, trace, retention); result.response.headers.set("X-Roleplay-Trace-ID", trace.id); result.completion = Promise.resolve(result.completion).then(async (completion) => { if (completion?.persistenceFailed) await trace.finish(false, "persistence_failed"); @@ -178,7 +184,8 @@ export class RoleplaySession extends DurableObject { } } - async handleTurn(request, settings, queueMs = 0, trace = null) { + async handleTurn(request, settings, queueMs = 0, trace = null, retention = resolveRoleplayRetention(this.env, request)) { + const stateRepository = createRetentionStateRepository(this.ctx.storage, this.stateRepository, retention, this.configuredCandidates); const scanCounts = [0, 0]; const applyScanHeader = headers => { if (scanCounts.some(Boolean)) headers.set(SECRET_SCAN_HEADER, `redacted=${scanCounts[0]}; observed=${scanCounts[1]}`); @@ -192,9 +199,9 @@ export class RoleplaySession extends DurableObject { let compactionMs = 0; const payload = await request.json(); if (payload.recovery_enabled !== undefined && typeof payload.recovery_enabled !== "boolean") throw new RoleplayRequestError("recovery_enabled must be a boolean"); - const stateCacheHit = this.stateRepository.loaded; + const stateCacheHit = stateRepository.loaded; const stateLoadStartedAt = performance.now(); - let state = await this.stateRepository.load(); + let state = await stateRepository.load(); const stateLoadMs = performance.now() - stateLoadStartedAt; state = recordRoleplayStateCache(state, stateCacheHit); const parsedInitial = parseRoleplayPayload( @@ -213,7 +220,8 @@ export class RoleplaySession extends DurableObject { state, parsedInitial, ); - const idempotencyKey = request.headers.get("Idempotency-Key") ?? ""; + const suppliedIdempotencyKey = request.headers.get("Idempotency-Key") ?? ""; + const idempotencyKey = retentionAllowsContent(retention) ? suppliedIdempotencyKey : await retentionRequestId(suppliedIdempotencyKey); const duplicate = existingRoleplayRequest(state, idempotencyKey); if (duplicate) { return { @@ -259,7 +267,7 @@ export class RoleplaySession extends DurableObject { }; state = markRoleplayRequest(state, idempotencyKey, "started"); if (idempotencyKey) { - await this.stateRepository.save(state); + await stateRepository.save(state); } const configuredCandidates = filterRoutingCandidates(this.configuredCandidates, parsed.routing); @@ -275,7 +283,7 @@ export class RoleplaySession extends DurableObject { const credentialCheckPerformed = checkedState !== state; if (checkedState !== state) { state = checkedState; - await this.stateRepository.save(state); + await stateRepository.save(state); } const rankFor = (preference) => rankRoleplayCandidates( configuredCandidates, @@ -301,7 +309,7 @@ export class RoleplaySession extends DurableObject { if (parsed.routing.fallback === "none") candidates.splice(1); if (!candidates.length) { state = markRoleplayRequest(state, idempotencyKey, "no_provider"); - await this.stateRepository.save(state); + await stateRepository.save(state); return { response: errorResponse( "No roleplay provider is configured for this model preference", @@ -394,7 +402,7 @@ export class RoleplaySession extends DurableObject { ); if (compacted.blockedResponse) { state = markRoleplayRequest(state, idempotencyKey, "provider_failed"); - await this.stateRepository.save(state); + await stateRepository.save(state); return { response: compacted.blockedResponse, completion: Promise.resolve(), @@ -467,7 +475,7 @@ export class RoleplaySession extends DurableObject { if (!preserveFullGeneration) { messagesOptimized += plan.olderMessages.length; } - await this.stateRepository.save(state); + await stateRepository.save(state); } } compactionMs = performance.now() - compactionStartedAt; @@ -485,7 +493,7 @@ export class RoleplaySession extends DurableObject { projectedStoredBytes > settings.maxStoredBytes ) { state = markRoleplayRequest(state, idempotencyKey, "compaction_failed"); - await this.stateRepository.save(state); + await stateRepository.save(state); return { response: errorResponse( "Automatic memory compaction could not produce a safe retained window", @@ -524,7 +532,7 @@ export class RoleplaySession extends DurableObject { ); if (!generationCandidates.length) { state = markRoleplayRequest(state, idempotencyKey, "context_too_large"); - await this.stateRepository.save(state); + await stateRepository.save(state); return { response: errorResponse( "Roleplay context and requested output exceed every eligible provider limit", @@ -535,7 +543,7 @@ export class RoleplaySession extends DurableObject { }; } - const recovery = recoveryTemplate(payload, roleplayMessages); + const recovery = recoveryTemplate(payload, roleplayMessages, retention); trace?.phase("connecting"); const attempted = await attemptRoleplayCandidates( state, @@ -561,9 +569,9 @@ export class RoleplaySession extends DurableObject { ); state = attempted.state; if (attempted.terminalResponse) { - await preserveRecovery(this.ctx.storage, recovery, { success: false, reason: "provider_failed" }, trace?.id); + await preserveRecovery(this.ctx.storage, recovery, { success: false, reason: "provider_failed" }, trace?.id, retention); state = markRoleplayRequest(state, idempotencyKey, "provider_failed"); - await this.stateRepository.save(state); + await stateRepository.save(state); return { response: attempted.terminalResponse, completion: Promise.resolve(), @@ -685,7 +693,7 @@ export class RoleplaySession extends DurableObject { detectRefusal: continuation.classifyRefusal, refusalFallbackEnabled: continuation.refusalFallbackEnabled, onComplete: async (completion) => { - await preserveRecovery(this.ctx.storage, recovery, completion, trace?.id); + await preserveRecovery(this.ctx.storage, recovery, completion, trace?.id, retention); const { success, assistant, @@ -739,8 +747,11 @@ export class RoleplaySession extends DurableObject { idempotencyKey, }); trace?.metrics(completion); - if (trace) await trace.finish(success, reason, (metadata) => this.stateRepository.save(state, metadata)); - else await this.stateRepository.save(state); + if (trace && retentionAllowsContent(retention)) await trace.finish(success, reason, (metadata) => stateRepository.save(state, metadata)); + else { + await trace?.finish(success, reason); + await stateRepository.save(state); + } }, }); return { @@ -839,9 +850,12 @@ export class RoleplaySession extends DurableObject { timings, }); trace?.selected(finalCandidate, parameterReceipt(parsed, finalCandidate, settings)); - if (trace) await trace.finish(completionResult.success, completionResult.reason, (metadata) => this.stateRepository.save(state, metadata)); - else await this.stateRepository.save(state); - await preserveRecovery(this.ctx.storage, recovery, completionResult, trace?.id); + if (trace && retentionAllowsContent(retention)) await trace.finish(completionResult.success, completionResult.reason, (metadata) => stateRepository.save(state, metadata)); + else { + await trace?.finish(completionResult.success, completionResult.reason); + await stateRepository.save(state); + } + await preserveRecovery(this.ctx.storage, recovery, completionResult, trace?.id, retention); applyScanHeader(responseHeaders); return { response: new Response(responseBytes, { diff --git a/worker/roleplay/recovery.mjs b/worker/roleplay/recovery.mjs index 45bc928b..cd8554b9 100644 --- a/worker/roleplay/recovery.mjs +++ b/worker/roleplay/recovery.mjs @@ -1,10 +1,14 @@ import { errorResponse, jsonResponse, readBoundedBytes } from "./transport.mjs"; import { createVisibleRoleplayContentCollector } from "./reasoning-output.mjs"; +import { retentionAllowsContent, retentionResponse } from "../retention-policy.mjs"; +export { resolveRoleplayRetention, retentionResponse, retentionRequestId, retentionAllowsContent } from "../retention-policy.mjs"; +export { createRetentionStateRepository } from "./session-storage.mjs"; const KEY = "operator_recovery_v1"; const MAX_BYTES = 100_000; -export function recoveryTemplate(payload, messages) { +export function recoveryTemplate(payload, messages, retentionPolicy = null) { + if (!retentionAllowsContent(retentionPolicy)) return null; if (payload.recovery_enabled !== true) return null; const result = { model: payload.model || "roleplay:auto", messages, routing: payload.routing, reasoning_effort: payload.reasoning_effort, @@ -16,7 +20,8 @@ export function recoveryTemplate(payload, messages) { return new TextEncoder().encode(JSON.stringify(result)).byteLength <= 60_000 ? result : null; } -export async function preserveRecovery(storage, template, result, traceId) { +export async function preserveRecovery(storage, template, result, traceId, retentionPolicy = null) { + if (!retentionAllowsContent(retentionPolicy)) return; if (!template || result.success) return; const visible = createVisibleRoleplayContentCollector(); const partial = typeof result.visiblePartial === "string" ? result.visiblePartial @@ -29,7 +34,9 @@ export async function preserveRecovery(storage, template, result, traceId) { await storage.put(KEY, snapshot); } -export async function handleRecoverySnapshot(session, request) { +export async function handleRecoverySnapshot(session, request, retentionPolicy = null) { + if (!retentionAllowsContent(retentionPolicy)) return retentionResponse( + errorResponse("Durable conversation recovery is unavailable under zero retention", 409, "recovery_unavailable"), retentionPolicy); if (session.pendingTurns) return errorResponse("Wait for the active turn to settle", 409, "session_busy"); let slot; try { diff --git a/worker/roleplay/session-storage.mjs b/worker/roleplay/session-storage.mjs index 5f7811e5..788657b1 100644 --- a/worker/roleplay/session-storage.mjs +++ b/worker/roleplay/session-storage.mjs @@ -228,7 +228,12 @@ export async function saveRoleplayState( state, previousState = null, metadata = {}, + retentionPolicy = null, ) { + if (retentionPolicy?.enabled && retentionPolicy.mode === "zero") { + await saveRetentionCounters(storage, state); + return; + } const { directives, messages, ...core } = state; const entries = { ...metadata, [STATE_KEY]: core }; if (!previousState || previousState.messages !== messages) { @@ -242,3 +247,63 @@ export async function saveRoleplayState( } await storage.put(entries); } + +const RETENTION_COUNTERS_KEY = "roleplay-retention-counters"; +const RETENTION_COUNTER_FIELDS = ["turns", "compactions", "localCompactions", "inputTokensSaved", + "stateCacheHits", "stateCacheMisses", "compactionFailures", "compactionBackoffUntil", "updatedAt", + "nanogptCredentialChecks"]; + +function retentionCounters(state) { + return Object.fromEntries(RETENTION_COUNTER_FIELDS.filter(key => Number.isFinite(state[key]) && state[key] >= 0) + .map(key => [key, state[key]])); +} + +const RETENTION_MODEL_FIELDS = ["attempts", "successes", "failures", "consecutiveFailures", "cooldownUntil", + "ewmaTtfbMs", "ewmaTotalMs", "lastStatus", "lastUsedAt", "ewmaTokensPerSecond", "lastCompletionTokens", + "lastGenerationMs", "semanticRefusals", "lastSemanticRefusalAt"]; +const RETENTION_SAMPLE_FIELDS = ["ttfbSamplesMs", "totalSamplesMs", "tokensPerSecondSamples", + "firstReasoningSamplesMs", "firstContentSamplesMs"]; + +async function retentionModelKey(key) { + const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key)); + return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, "0")).join(""); +} + +function retentionModelCounters(stats) { + const counters = Object.fromEntries(RETENTION_MODEL_FIELDS.filter(key => Number.isFinite(stats?.[key]) && stats[key] >= 0) + .map(key => [key, stats[key]])); + for (const key of RETENTION_SAMPLE_FIELDS) { + if (Array.isArray(stats?.[key])) counters[key] = stats[key].filter(value => Number.isFinite(value) && value >= 0).slice(-64); + } + return counters; +} + +async function saveRetentionCounters(storage, state) { + const counters = retentionCounters(state); + counters.stats = Object.fromEntries(await Promise.all(Object.entries(state.stats ?? {}).map(async ([key, stats]) => + [await retentionModelKey(key), retentionModelCounters(stats)]))); + // Request identities are already hashed at the turn boundary. Ignore arbitrary metadata. + counters.recentRequests = (state.recentRequests ?? []).filter(row => /^[a-f0-9]{64}$/.test(row.key) + && Number.isFinite(row.at) && /^[a-z_]{1,64}$/.test(row.status)) + .map(({ key, at, status }) => ({ key, at, status })).slice(-32); + await storage.put(RETENTION_COUNTERS_KEY, counters); +} + +export function createRetentionStateRepository(storage, repository, policy, candidates = []) { + if (!policy?.enabled || policy.mode !== "zero") return repository; + return { + loaded: false, + async load() { + const saved = await storage.get(RETENTION_COUNTERS_KEY) ?? {}; + const entries = await Promise.all(candidates.map(async candidate => { + const prior = saved.stats?.[await retentionModelKey(candidate.key)]; + return prior ? [candidate.key, { provider: candidate.provider, model: candidate.model, + family: candidate.family, ...retentionModelCounters(prior) }] : null; + })); + const stats = Object.fromEntries(entries.filter(Boolean)); + return { ...createInitialRoleplayState(), ...retentionCounters(saved), + stats, recentRequests: Array.isArray(saved.recentRequests) ? saved.recentRequests : [] }; + }, + async save(state) { await saveRetentionCounters(storage, state); return state; }, + }; +} diff --git a/worker/roleplay/turn-trace.mjs b/worker/roleplay/turn-trace.mjs index 4bc53a86..84dad3e5 100644 --- a/worker/roleplay/turn-trace.mjs +++ b/worker/roleplay/turn-trace.mjs @@ -16,7 +16,8 @@ export class TurnTraceJournal { }).catch(() => {}); } - begin() { + begin(retentionPolicy = null) { + const retainContent = !retentionPolicy?.enabled || retentionPolicy.mode !== "zero"; const row = { id: crypto.randomUUID(), startedAt: Date.now(), phase: "queued", events: [], metrics: {} }; this.records.push(row); @@ -35,6 +36,7 @@ export class TurnTraceJournal { return { id: row.id, phase, metrics, selected(candidate, receipt) { + if (!retainContent) return; row.provider = candidate.provider; row.model = candidate.model; row.parameters = receipt; @@ -49,7 +51,15 @@ export class TurnTraceJournal { phase(success ? "completed" : "interrupted"); row.finishedAt = Date.now(); row.reason = /^[a-z0-9_]{1,64}$/.test(reason) ? reason : "failed"; - const completed = this.records.filter((item) => item.finishedAt); + if (!retainContent) { + // Do not rewrite old content traces or call a conversation persistence callback. + row.retention = "zero"; + const safe = structuredClone(this.records.filter(item => item.finishedAt && item.retention === "zero")); + this.writes = this.writes.catch(() => {}).then(() => this.storage.put("zero-turn-traces-v1", safe)); + try { await this.writes; } catch { row.diagnosticsPersisted = false; } + return; + } + const completed = this.records.filter((item) => item.finishedAt && item.retention !== "zero"); this.writes = this.writes.catch(() => {}).then(() => persist ? persist({ [KEY]: completed }) : this.storage.put(KEY, completed)); try { await this.writes; } catch (error) { row.diagnosticsPersisted = false;