From a15daf3d06f6013b856f11f82e6bc4dda840f0e6 Mon Sep 17 00:00:00 2001 From: Abhyudaya Baiju Tharakan Date: Fri, 9 Oct 2026 06:52:04 +0530 Subject: [PATCH] feat(context): add opt-in reversible context paging Behind CONTEXT_PAGING_ENABLED (default off), a managed client that declares the multillm_context_retrieve capability can have complete older exchanges replaced by signed retrieval handles instead of being summarized or truncated. Pages keep the exact stored JSON, never split a tool call from its results, and are scoped to the principal, session and policy revision. Bodies go in the existing R2 bucket and metadata in D1 (migration 0024), with 64 KiB per page, 1 MiB per session and a one-hour TTL. Zero-content retention disables paging, and a request whose protected content still does not fit returns 413. --- docs/context-pages.md | 79 +++++ .../0024_context_pages.sql | 13 + package.json | 2 +- routes/context_pages.py | 34 ++ services/context_optimizer.py | 20 ++ services/context_pages.py | 275 ++++++++++++++++ tests/fixtures/secret_firewall_coverage.json | 4 + tests/test_context_pages.py | 265 +++++++++++++++ tests/test_context_pages_worker.mjs | 268 +++++++++++++++ worker/container-env.mjs | 1 + worker/context-pages-d1.mjs | 309 ++++++++++++++++++ worker/d1-schema.mjs | 2 +- worker/roleplay/capacity.mjs | 26 ++ worker/roleplay/memory.mjs | 29 +- 14 files changed, 1318 insertions(+), 9 deletions(-) create mode 100644 docs/context-pages.md create mode 100644 intelligence-migrations/0024_context_pages.sql create mode 100644 routes/context_pages.py create mode 100644 services/context_pages.py create mode 100644 tests/test_context_pages.py create mode 100644 tests/test_context_pages_worker.mjs create mode 100644 worker/context-pages-d1.mjs diff --git a/docs/context-pages.md b/docs/context-pages.md new file mode 100644 index 00000000..c28ebd21 --- /dev/null +++ b/docs/context-pages.md @@ -0,0 +1,79 @@ +# Reversible context paging + +Context paging replaces complete older conversation exchanges with retrieval handles. +It preserves the exact JSON body of each stored exchange, including whitespace and +Unicode in message content, tool-call IDs, arguments, and tool results. It does not +summarize history or invent a tool call. System and developer messages, incomplete +exchanges, explicitly protected indices, and the latest user exchange remain in full. + +Paging is off by default. Leave `CONTEXT_PAGING_ENABLED` unset, empty, or `false` to +keep existing traffic and storage unchanged. Invalid flag values disable paging and +produce one warning containing only the setting name. Raw forwarding is unchanged. + +## Enable for a managed client + +Apply the context-pages migration before setting `CONTEXT_PAGING_ENABLED=true`. +The deployment must expose the authenticated context retrieval route and private +storage operation, and supply verified principal, session, current policy revision, +current chat/tool grants, and retention decisions to the managed dispatch path. +The same existing `multillm_media` R2 bucket holds bodies under `context-pages/`; +`INTELLIGENCE_DB.context_pages` holds metadata. There are no additional bindings. +The existing media signing secret (or Flask signing secret) signs page handles. + +A managed client explicitly declares retrieval capability: + +```json +{ + "model": "provider:explicit-model", + "capabilities": ["multillm_context_retrieve"], + "messages": [ + {"role": "user", "content": "Older complete exchange"}, + {"role": "assistant", "content": "Older answer"}, + {"role": "user", "content": "Current request"} + ] +} +``` + +Only exchanges that need paging to fit the candidate's input window are stored. +The upstream messages contain a handle marker instead of the old group, plus the +`multillm_context_retrieve` function schema. Page metadata returned to the client is +`{page_id, sha256, expires_at, tool_schema}`; expiry is a Unix timestamp. The managed +response exposes this as `context_pages`. No body or base64 blob is attached to the +upstream generation request. The explicit model and output reservation are preserved. + +Retrieve only when needed by calling `multillm_context_retrieve({"page_id":"cp_..."})` +or making an authenticated `GET /v1/context/pages/cp_...`. The caller's current grants +and policy revision must still authorize access; a handle alone does not grant access. +The route returns `page_id`, `sha256`, `expires_at`, `messages`, and `body_base64`. +`body_base64` decodes to the exact UTF-8 bytes that were hashed and stored. Responses +use `Cache-Control: private, no-store`. Retrieving does not dispatch a provider call; +the client chooses whether to include restored content in a later generation. + +With the flag off, the same request keeps its original history and does not write +pages. A client without the capability also keeps its existing behavior. Zero-content +retention disables paging before any storage call and denies retrieval of existing +pages for that request. Changing policy does not delete earlier retained objects. + +## Bounds and errors + +- Each page holds at most 64 KiB; active pages hold at most 1 MiB per principal/session. + The D1 limit check and all metadata inserts run in one statement, so competing + writers cannot exceed the session allowance. Candidate plans reuse identical pages + within one request. +- Pages expire after 3,600 seconds. Every retrieval checks expiry, ownership, session, + current revision, the HMAC, byte length, and SHA-256 before exposing content. +- HTTP 413 `context_window_exceeded` means protected content and handles cannot fit + the candidate window after reserving output and safety tokens. Nothing is silently + truncated. Oversized pages/session content also return 413. +- HTTP 404 covers disabled retrieval, absent, expired, foreign, or stale-revision + handles. HTTP 403 covers missing current grants or zero retention. +- HTTP 503 JSON reports unavailable D1 tables, R2 bindings, signing configuration, + authority, or storage, and corrupted bodies. Generation must stop before dispatch. + Failed storage is never permission to truncate, summarize, or replay a generation. + +Token estimates use serialized UTF-8 byte counts, not a provider tokenizer. Retrieval +can increase a later request's input cost; paging does not authorize a model or budget +change. Configure an R2 lifecycle rule for `context-pages/` according to retention +policy: expiry denies access immediately, but physical storage cleanup follows that +rule. D1 metadata may be retained for operations; expired metadata does not count +against the active session allowance. No prompt or retrieved body is logged. diff --git a/intelligence-migrations/0024_context_pages.sql b/intelligence-migrations/0024_context_pages.sql new file mode 100644 index 00000000..7e3e1884 --- /dev/null +++ b/intelligence-migrations/0024_context_pages.sql @@ -0,0 +1,13 @@ +-- Page bodies live only in the context-pages/ prefix of multillm_media. +CREATE TABLE IF NOT EXISTS context_pages ( + page_id TEXT PRIMARY KEY, + principal TEXT NOT NULL, + session_hash TEXT NOT NULL, + revision TEXT NOT NULL, + sha256 TEXT NOT NULL, + byte_length INTEGER NOT NULL CHECK (byte_length > 0 AND byte_length <= 65536), + expires_at INTEGER NOT NULL, + r2_key TEXT NOT NULL UNIQUE +); +CREATE INDEX IF NOT EXISTS context_pages_session_expiry + ON context_pages (principal, session_hash, expires_at); diff --git a/package.json b/package.json index e90d16c7..eba39e65 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 tests/test_managed_idempotency_worker.mjs tests/test_wave3_hub_worker.mjs tests/test_wave3_transport_worker.mjs tests/test_admission_leases_worker.mjs tests/test_edge_request_metrics_worker.mjs tests/test_request_cancellation_worker.mjs tests/test_mcp_contract_drift_worker.mjs tests/test_zero_content_retention_worker.mjs tests/test_prompt_cache_cost_worker.mjs tests/test_config_revision_sync_worker.mjs tests/test_gateway_alerts_worker.mjs tests/test_session_tiers_worker.mjs tests/test_usage_reservations_worker.mjs tests/test_shared_generation_cache_worker.mjs tests/test_deferred_tools_worker.mjs tests/test_generation_deadline_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_managed_idempotency_worker.mjs tests/test_wave3_hub_worker.mjs tests/test_wave3_transport_worker.mjs tests/test_admission_leases_worker.mjs tests/test_edge_request_metrics_worker.mjs tests/test_request_cancellation_worker.mjs tests/test_mcp_contract_drift_worker.mjs tests/test_zero_content_retention_worker.mjs tests/test_prompt_cache_cost_worker.mjs tests/test_config_revision_sync_worker.mjs tests/test_context_pages_worker.mjs tests/test_gateway_alerts_worker.mjs tests/test_session_tiers_worker.mjs tests/test_usage_reservations_worker.mjs tests/test_shared_generation_cache_worker.mjs tests/test_deferred_tools_worker.mjs tests/test_generation_deadline_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/routes/context_pages.py b/routes/context_pages.py new file mode 100644 index 00000000..c81c6047 --- /dev/null +++ b/routes/context_pages.py @@ -0,0 +1,34 @@ +"""Registration boundary for authenticated context retrieval.""" +from __future__ import annotations + +from flask import jsonify + +from services.context_pages import ContextPageError, ContextPageService, paging_enabled + + +def register_context_page_routes(app, *, service: ContextPageService | None = None, authorize=None) -> None: + """authorize resolves current principal, session, revision, chat grant and retention. + + The callback must authenticate the request; callers never select authority through + URL/query fields. An absent authority or storage collaborator fails closed. + """ + service = service or ContextPageService() + + @app.route("/v1/context/pages/", methods=["GET"]) + def retrieve_context_page(page_id): + try: + if not paging_enabled(): + raise ContextPageError("context_page_not_found", 404) + if authorize is None: + raise ContextPageError("context_paging_authority_unavailable") + authority = authorize() + if not isinstance(authority, dict) or not {"scope", "retention_policy", "granted"} <= set(authority): + raise ContextPageError("context_paging_authority_unavailable") + result = service.retrieve(page_id=page_id, scope=authority["scope"], + retention_policy=authority["retention_policy"], granted=authority["granted"] is True) + response = jsonify(result) + except ContextPageError as error: + response = jsonify({"error": error.code, "message": "Context page retrieval could not be completed."}) + response.status_code = error.status + response.headers["Cache-Control"] = "private, no-store" + return response diff --git a/services/context_optimizer.py b/services/context_optimizer.py index 6cbe2967..65e6ac67 100644 --- a/services/context_optimizer.py +++ b/services/context_optimizer.py @@ -8,6 +8,7 @@ from typing import Any from services.context_analysis_cache import ContextAnalysisCache, ImagePromptSpan +from services.context_pages import PagingRequest EARLIER_IMAGE_PROMPT_PLACEHOLDER = ( "[Earlier image-generation prompt omitted by MultiLLM context optimizer; " @@ -127,6 +128,7 @@ class ContextOptimizationResult: reasons: tuple[str, ...] analysis_cache_hits: int analysis_cache_misses: int + pages: tuple[dict[str, Any], ...] = () def estimate_payload_tokens(payload: Mapping[str, Any]) -> int: @@ -478,6 +480,7 @@ def optimize_chat_payload( default_target_tokens: int, summary_digest: Mapping[str, list[str]] | None = None, defer_required_target: bool = False, + context_paging: PagingRequest | None = None, ) -> ContextOptimizationResult: if not isinstance(payload, Mapping): raise ContextOptimizationError("Request body must be a JSON object") @@ -491,6 +494,23 @@ def optimize_chat_payload( ) optimized_payload = copy.deepcopy(dict(payload)) optimized_payload.pop("optimization", None) + if context_paging is not None and context_paging.eligible(): + before = estimate_payload_tokens(optimized_payload) + paged = context_paging.service.page_payload( + optimized_payload, scope=context_paging.scope, + capabilities=context_paging.capabilities, + target_input_tokens=options.target_input_tokens, + retention_policy=context_paging.retention_policy, managed=context_paging.managed, + protected_indices=options.preserve_message_indices, + ) + after = estimate_payload_tokens(paged.payload) + return ContextOptimizationResult( + payload=dict(paged.payload), options=options, status="paged" if paged.pages else "unchanged", + estimated_input_before=before, estimated_input_after=after, + image_prompts_compacted=0, messages_summarized=0, summary_source_messages=(), + needs_summary=False, target_met=after <= options.target_input_tokens, + reasons=(), analysis_cache_hits=0, analysis_cache_misses=0, pages=paged.pages, + ) messages = optimized_payload["messages"] before_tokens = estimate_payload_tokens(optimized_payload) triggered = before_tokens > options.trigger_input_tokens diff --git a/services/context_pages.py b/services/context_pages.py new file mode 100644 index 00000000..06f2d066 --- /dev/null +++ b/services/context_pages.py @@ -0,0 +1,275 @@ +"""Exact, principal-scoped context pages with a durable storage boundary.""" +from __future__ import annotations + +import base64 +import copy +import hashlib +import hmac +import json +import logging +import os +import re +import time +from dataclasses import dataclass +from functools import lru_cache +from typing import Any, Callable, Mapping + +from services.retention_policy import RetentionPolicy + +MAX_PAGE_BYTES = 64 * 1024 +MAX_SESSION_BYTES = 1024 * 1024 +TTL_SECONDS = 3600 +PAGE_ID = re.compile(r"cp_[a-f0-9]{32}_[A-Za-z0-9_-]{43}\Z") +TOOL_SCHEMA = {"type": "function", "function": { + "name": "multillm_context_retrieve", "description": "Retrieve an exact stored historical context page.", + "parameters": {"type": "object", "properties": {"page_id": {"type": "string"}}, + "required": ["page_id"], "additionalProperties": False}}} +logger = logging.getLogger(__name__) + + +class ContextPageError(ValueError): + def __init__(self, code: str, status: int = 503): + super().__init__(code) + self.code = code + self.status = status + + +@dataclass(frozen=True) +class PageScope: + principal: str + session: str + revision: str + + def wire(self) -> dict[str, str]: + values = {"principal": self.principal, "session": self.session, "revision": self.revision} + if any(not isinstance(value, str) or not value or len(value.encode()) > 256 for value in values.values()): + raise ContextPageError("context_paging_authority_unavailable") + return values + + +@dataclass(frozen=True) +class PagingResult: + payload: Mapping[str, Any] + pages: tuple[dict[str, Any], ...] = () + + +@dataclass(frozen=True) +class PagingRequest: + service: ContextPageService + scope: PageScope + capabilities: list[str] + retention_policy: RetentionPolicy + managed: bool = False + + def eligible(self) -> bool: + return paging_enabled() and self.managed and self.retention_policy.allows_content and capability_enabled(self.capabilities) + + +@lru_cache(maxsize=1) +def _warn_invalid_flag() -> None: + logger.warning("Invalid CONTEXT_PAGING_ENABLED; context paging disabled") + + +def paging_enabled(env: Mapping[str, str] | None = None) -> bool: + flag = str((os.environ if env is None else env).get("CONTEXT_PAGING_ENABLED", "")).strip().lower() + if flag in {"", "0", "false", "no", "off"}: + return False + if flag in {"1", "true", "yes", "on"}: + return True + _warn_invalid_flag() + return False + + +def capability_enabled(capabilities: Any) -> bool: + return isinstance(capabilities, (list, tuple)) and "multillm_context_retrieve" in capabilities + + +def encode_group(group: list[dict[str, Any]]) -> bytes: + try: + return json.dumps(group, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8") + except (TypeError, ValueError, UnicodeError): + raise ContextPageError("invalid_context_messages", 400) from None + + +def _complete(group: list[Any]) -> bool: + pending: set[str] = set() + seen: set[str] = set() + for message in group: + if not isinstance(message, dict) or message.get("role") not in {"user", "assistant", "tool"}: + return False + if any(key in message for key in ("function_call", "tool_use", "tool_uses")): + return False + calls = message.get("tool_calls", []) + if not isinstance(calls, list) or (calls and message["role"] != "assistant"): + return False + if pending and message["role"] != "tool": + return False + for call in calls: + call_id = call.get("id") if isinstance(call, dict) else None + if not isinstance(call_id, str) or not call_id or call_id in seen: + return False + pending.add(call_id) + seen.add(call_id) + if message["role"] == "tool": + call_id = message.get("tool_call_id") + if not isinstance(call_id, str) or call_id not in pending: + return False + pending.remove(call_id) + return not pending and bool(group) and group[-1].get("role") in {"assistant", "tool"} + + +def removable_groups(messages: list[Any], protected_indices: tuple[int, ...] = ()) -> list[tuple[int, int]]: + starts = [index for index, message in enumerate(messages) + if isinstance(message, dict) and message.get("role") == "user"] + return [(start, end) for start, end in zip(starts, starts[1:]) + if not any(start <= index < end for index in protected_indices) and _complete(messages[start:end])] + + +def page_marker(metadata: Mapping[str, Any]) -> dict[str, str]: + handle = {key: metadata[key] for key in ("page_id", "sha256", "expires_at")} + return {"role": "assistant", "content": "[Stored historical context; retrieve explicitly with multillm_context_retrieve]\n" + + json.dumps(handle, separators=(",", ":"))} + + +def _metadata(value: Any, body: bytes, now: int) -> dict[str, Any]: + if (not isinstance(value, dict) or not isinstance(value.get("page_id"), str) + or not PAGE_ID.fullmatch(value["page_id"]) or value.get("sha256") != hashlib.sha256(body).hexdigest() + or type(value.get("expires_at")) is not int or not now < value["expires_at"] <= now + TTL_SECONDS + or value.get("tool_schema") != TOOL_SCHEMA): + raise ContextPageError("context_page_integrity_failed") + return {key: copy.deepcopy(value[key]) for key in ("page_id", "sha256", "expires_at", "tool_schema")} + + +class PrivatePageStore: + """The authenticated private dispatcher supplies this fixed transport callback.""" + def __init__(self, call: Callable[[dict[str, Any]], dict[str, Any]]): + self.call = call + + def _request(self, payload): + try: + result = self.call(payload) + except Exception as error: + status = getattr(error, "status", 503) + code = getattr(error, "code", "context_paging_unavailable") + if status not in {400, 403, 404, 413, 503} or not isinstance(code, str) or not re.fullmatch(r"[a-z_]{1,64}", code): + status, code = 503, "context_paging_unavailable" + raise ContextPageError(code, status) from None + if not isinstance(result, dict): + raise ContextPageError("context_paging_unavailable") + if isinstance(result.get("error"), dict): + raise ContextPageError("context_paging_unavailable") + return result + + def put(self, scope: PageScope, bodies: list[bytes]) -> list[dict[str, Any]]: + return self._request({"operation": "put", "scope": scope.wire(), "granted": True, + "retention_policy": {"mode": "inherit", "enabled": False}, + "bodies": [base64.b64encode(body).decode() for body in bodies]})["pages"] + + def get(self, scope: PageScope, page_id: str) -> dict[str, Any]: + return self._request({"operation": "get", "scope": scope.wire(), "page_id": page_id, "granted": True, + "retention_policy": {"mode": "inherit", "enabled": False}}) + + +class ContextPageService: + def __init__(self, store=None, *, clock: Callable[[], float] = time.time): + self.store = store + self.clock = clock + + def _call(self, operation: str, *args): + if self.store is None: + raise ContextPageError("context_paging_unavailable") + try: + return getattr(self.store, operation)(*args) + except ContextPageError: + raise + except Exception: + # Never log storage exceptions: adapters may include request content. + raise ContextPageError("context_paging_unavailable") from None + + def page_payload(self, payload: Mapping[str, Any], *, scope: PageScope, capabilities: list[str], + target_input_tokens: int, retention_policy: RetentionPolicy, managed: bool = False, + protected_indices: tuple[int, ...] = (), + estimate_tokens: Callable[[Mapping[str, Any]], int] | None = None) -> PagingResult: + if not paging_enabled() or not managed or not capability_enabled(capabilities) or not retention_policy.allows_content: + return PagingResult(payload) + scope.wire() + if type(target_input_tokens) is not int or target_input_tokens <= 0: + raise ContextPageError("context_window_exceeded", 413) + if estimate_tokens is None: + from services.context_optimizer import estimate_payload_tokens + estimate_tokens = estimate_payload_tokens + if self.store is None: + raise ContextPageError("context_paging_unavailable") + if estimate_tokens(payload) <= target_input_tokens: + return PagingResult(payload) + view = copy.deepcopy(dict(payload)) + messages = view.get("messages") + if not isinstance(messages, list): + raise ContextPageError("invalid_context_messages", 400) + tools = view.get("tools", []) + if not isinstance(tools, list) or any(not isinstance(tool, dict) or not isinstance(tool.get("function"), dict) for tool in tools): + raise ContextPageError("invalid_context_tools", 400) + if any(tool.get("function", {}).get("name") == "multillm_context_retrieve" for tool in tools if isinstance(tool, dict)): + raise ContextPageError("context_retrieval_tool_conflict", 400) + view["tools"] = [*tools, copy.deepcopy(TOOL_SCHEMA)] + selected: list[tuple[int, int, bytes]] = [] + replacements: dict[int, dict[str, str]] = {} + removed: set[int] = set() + now = int(self.clock()) + for start, end in removable_groups(messages, protected_indices): + body = encode_group(messages[start:end]) + if len(body) > MAX_PAGE_BYTES: + raise ContextPageError("context_page_limit", 413) + selected.append((start, end, body)) + if sum(len(item[2]) for item in selected) > MAX_SESSION_BYTES: + raise ContextPageError("context_session_limit", 413) + replacements[start] = page_marker({"page_id": "cp_" + "0" * 32 + "_" + "s" * 43, + "sha256": hashlib.sha256(body).hexdigest(), "expires_at": now + TTL_SECONDS}) + removed.update(range(start + 1, end)) + view["messages"] = [replacements.get(index, message) for index, message in enumerate(messages) if index not in removed] + if estimate_tokens(view) <= target_input_tokens: + break + if estimate_tokens(view) > target_input_tokens or not selected: + raise ContextPageError("context_window_exceeded", 413) + stored = self._call("put", scope, [item[2] for item in selected]) + if not isinstance(stored, list) or len(stored) != len(selected): + raise ContextPageError("context_page_integrity_failed") + metadata = tuple(_metadata(meta, item[2], now) for meta, item in zip(stored, selected)) + for meta, (start, _, _) in zip(metadata, selected): + replacements[start] = page_marker(meta) + view["messages"] = [replacements.get(index, message) for index, message in enumerate(messages) if index not in removed] + if estimate_tokens(view) > target_input_tokens: + raise ContextPageError("context_window_exceeded", 413) + return PagingResult(view, metadata) + + def retrieve(self, scope: PageScope, page_id: str, *, retention_policy: RetentionPolicy, + granted: bool = True) -> dict[str, Any]: + if not paging_enabled(): + raise ContextPageError("context_page_not_found", 404) + if not granted or not retention_policy.allows_content: + raise ContextPageError("context_page_forbidden", 403) + scope.wire() + if not isinstance(page_id, str) or not PAGE_ID.fullmatch(page_id): + raise ContextPageError("context_page_not_found", 404) + result = self._call("get", scope, page_id) + if not isinstance(result, dict): + raise ContextPageError("context_page_integrity_failed") + if type(result.get("expires_at")) is not int or result["expires_at"] <= int(self.clock()): + raise ContextPageError("context_page_not_found", 404) + try: + body = base64.b64decode(result["body_base64"], validate=True) + messages = json.loads(body) + except (ValueError, KeyError, TypeError): + raise ContextPageError("context_page_integrity_failed") from None + if (len(body) > MAX_PAGE_BYTES or not isinstance(messages, list) or not _complete(messages) + or result.get("page_id") != page_id or not isinstance(result.get("sha256"), str) + or not re.fullmatch(r"[a-f0-9]{64}", result["sha256"]) + or not hmac.compare_digest(hashlib.sha256(body).hexdigest(), result["sha256"])): + raise ContextPageError("context_page_integrity_failed") + return {"page_id": page_id, "sha256": result["sha256"], "expires_at": result["expires_at"], + "body_base64": result["body_base64"], "messages": messages} + + def retrieve_tool(self, arguments: Any, **authority) -> dict[str, Any]: + if not isinstance(arguments, dict) or set(arguments) != {"page_id"}: + raise ContextPageError("invalid_context_retrieve", 400) + return self.retrieve(page_id=arguments["page_id"], **authority) diff --git a/tests/fixtures/secret_firewall_coverage.json b/tests/fixtures/secret_firewall_coverage.json index 2c079f26..db425253 100644 --- a/tests/fixtures/secret_firewall_coverage.json +++ b/tests/fixtures/secret_firewall_coverage.json @@ -15,6 +15,9 @@ "app.post('/admin/config/snapshots//apply')", "app.route('/admin/config/snapshots', methods=['GET', 'POST'])" ], + "routes/context_pages.py": [ + "app.route('/v1/context/pages/', methods=['GET'])" + ], "routes/core.py": [ "app.route('/')", "app.route('/admin/metrics/requests')", @@ -229,6 +232,7 @@ "worker/client-headers.mjs", "worker/config-revision.mjs", "worker/container-env.mjs", + "worker/context-pages-d1.mjs", "worker/control-audit-d1.mjs", "worker/control-state-d1.mjs", "worker/control-users-d1.mjs", diff --git a/tests/test_context_pages.py b/tests/test_context_pages.py new file mode 100644 index 00000000..39a601c2 --- /dev/null +++ b/tests/test_context_pages.py @@ -0,0 +1,265 @@ +"""Reversible paging uses synthetic content and injected storage only.""" +import base64 +import copy +import hashlib +import json +import sqlite3 +from pathlib import Path + +import pytest +from flask import Flask + +from services import context_pages as pages +from services.context_optimizer import optimize_chat_payload +from services.retention_policy import RetentionPolicy +from routes.context_pages import register_context_page_routes + + +class Store: + def __init__(self): + self.records = {} + self.calls = 0 + + def put(self, scope, bodies): + self.calls += 1 + if sum(len(body) for body in bodies) + sum(len(row[2]) for row in self.records.values()) > pages.MAX_SESSION_BYTES: + raise pages.ContextPageError("context_session_limit", 413) + result = [] + for body in bodies: + meta = {"page_id": "cp_" + str(len(self.records)).zfill(32) + "_" + "s" * 43, + "sha256": hashlib.sha256(body).hexdigest(), "expires_at": 4600, + "tool_schema": copy.deepcopy(pages.TOOL_SCHEMA)} + self.records[meta["page_id"]] = (scope, meta, body) + result.append(meta) + return result + + def get(self, scope, page_id): + self.calls += 1 + row = self.records.get(page_id) + if row is None or row[0] != scope: + raise pages.ContextPageError("context_page_not_found", 404) + return {**row[1], "body_base64": base64.b64encode(row[2]).decode()} + + +def history(): + return [{"role": "system", "content": "Exact directive"}, + {"role": "user", "content": "old 雪\n" * 600}, + {"role": "assistant", "content": None, "tool_calls": [ + {"id": "a", "type": "function", "function": {"name": "read", "arguments": "{}"}}, + {"id": "b", "type": "function", "function": {"name": "read", "arguments": "{}"}}]}, + {"role": "tool", "tool_call_id": "b", "content": " bytes\n\t雪 "}, + {"role": "tool", "tool_call_id": "a", "content": "answer"}, + {"role": "assistant", "content": "Done"}, + {"role": "user", "content": "Current request"}] + + +@pytest.fixture +def setup(monkeypatch): + monkeypatch.setenv("CONTEXT_PAGING_ENABLED", "true") + store = Store() + service = pages.ContextPageService(store, clock=lambda: 1000) + scope = pages.PageScope("alice", "session", "rev-1") + return service, store, scope + + +def page(setup, messages=None, **kw): + service, _, scope = setup + return service.page_payload({"model": "fixture", "messages": messages or history()}, scope=scope, + capabilities=["multillm_context_retrieve"], target_input_tokens=500, + retention_policy=RetentionPolicy(), managed=True, **kw) + + +def test_exact_tool_exchange_roundtrip_and_no_raw_blob(setup): + service, store, scope = setup + original = history() + result = page(setup, original) + assert result.payload["messages"][0] == original[0] + assert result.payload["messages"][-1] == original[-1] + assert "old 雪" not in json.dumps(result.payload, ensure_ascii=False) + restored = service.retrieve(scope, result.pages[0]["page_id"], retention_policy=RetentionPolicy()) + assert restored["messages"] == original[1:-1] + assert base64.b64decode(restored["body_base64"]) == pages.encode_group(original[1:-1]) + assert restored["sha256"] == hashlib.sha256(pages.encode_group(original[1:-1])).hexdigest() + assert original == history() and store.calls == 2 + assert result.payload["tools"][-1] == pages.TOOL_SCHEMA + + +@pytest.mark.parametrize("flag", ["", "false", "invalid"]) +def test_default_off_has_no_storage_or_mutation(setup, monkeypatch, flag): + service, store, scope = setup + monkeypatch.setenv("CONTEXT_PAGING_ENABLED", flag) + payload = {"messages": history()} + result = service.page_payload(payload, scope=scope, capabilities=["multillm_context_retrieve"], + target_input_tokens=1, retention_policy=RetentionPolicy(), managed=True) + assert result.payload is payload and not result.pages and store.calls == 0 + + +@pytest.mark.parametrize("managed,capabilities,retention", [ + (False, ["multillm_context_retrieve"], RetentionPolicy()), + (True, [], RetentionPolicy()), + (True, ["multillm_context_retrieve"], RetentionPolicy("zero", True)), +]) +def test_raw_capability_and_retention_bypass_before_storage(setup, managed, capabilities, retention): + service, store, scope = setup + payload = {"messages": history()} + result = service.page_payload(payload, scope=scope, capabilities=capabilities, + target_input_tokens=1, retention_policy=retention, managed=managed) + assert result.payload is payload and store.calls == 0 + + +@pytest.mark.parametrize("variant", ["foreign", "revision", "expired", "digest", "revoked", "zero"]) +def test_retrieval_failures(setup, variant): + service, store, scope = setup + meta = page(setup).pages[0] + if variant == "foreign": + scope = pages.PageScope("bob", "session", "rev-1") + if variant == "revision": + scope = pages.PageScope("alice", "session", "rev-2") + if variant == "expired": + service.clock = lambda: 4600 + if variant == "digest": + old_scope, old_meta, body = store.records[meta["page_id"]] + store.records[meta["page_id"]] = old_scope, old_meta, body + b" " + with pytest.raises(pages.ContextPageError) as error: + service.retrieve(scope, meta["page_id"], retention_policy=RetentionPolicy("zero", variant == "zero"), + granted=variant != "revoked") + assert error.value.status in {403, 404, 503} + + +@pytest.mark.parametrize("mutation", ["missing", "duplicate", "legacy", "protected"]) +def test_incomplete_and_protected_groups_never_page(setup, mutation): + messages = history() + if mutation == "missing": + messages.pop(4) + if mutation == "duplicate": + messages[4]["tool_call_id"] = "b" + if mutation == "legacy": + messages[2]["function_call"] = {"name": "legacy", "arguments": "{}"} + if mutation == "protected": + messages.insert(3, {"role": "developer", "content": "Protect this exchange"}) + with pytest.raises(pages.ContextPageError, match="context_window_exceeded") as error: + page(setup, messages) + assert error.value.status == 413 and setup[1].calls == 0 + + +def test_page_and_protected_window_limits_before_storage(setup): + messages = history() + messages[-1]["content"] = "protected" * 1000 + with pytest.raises(pages.ContextPageError, match="context_window_exceeded"): + page(setup, messages) + messages = history() + messages[1]["content"] = "x" * pages.MAX_PAGE_BYTES + with pytest.raises(pages.ContextPageError, match="context_page_limit"): + page(setup, messages) + assert setup[1].calls == 0 + + +def test_enabled_missing_backend_503(setup): + service, _, _ = setup + service.store = None + with pytest.raises(pages.ContextPageError) as error: + page(setup) + assert error.value.status == 503 + + +def test_optimizer_uses_exact_paging_before_lossy_optimization(setup): + service, _, scope = setup + payload = {"messages": history(), "optimization": {"target_input_tokens": 500, "keep_recent_turns": 1}} + result = optimize_chat_payload(payload, default_target_tokens=500, context_paging=pages.PagingRequest( + service, scope, ["multillm_context_retrieve"], RetentionPolicy(), True)) + assert result.status == "paged" and result.pages + assert not result.needs_summary and result.messages_summarized == 0 + + +def test_registered_route_checks_current_authority_and_returns_exact_bytes(setup): + service, _, scope = setup + meta = page(setup).pages[0] + app = Flask(__name__) + authority = {"scope": scope, "granted": True, "retention_policy": RetentionPolicy()} + register_context_page_routes(app, service=service, authorize=lambda: authority) + client = app.test_client() + response = client.get("/v1/context/pages/" + meta["page_id"]) + assert response.status_code == 200 + assert base64.b64decode(response.json["body_base64"]) == pages.encode_group(history()[1:-1]) + assert response.headers["Cache-Control"] == "private, no-store" + authority["granted"] = False + assert client.get("/v1/context/pages/" + meta["page_id"]).status_code == 403 + authority["granted"] = True + authority["scope"] = pages.PageScope("bob", "session", "rev-1") + assert client.get("/v1/context/pages/" + meta["page_id"]).status_code == 404 + service.store = None + assert client.get("/v1/context/pages/" + meta["page_id"]).status_code == 503 + + +def test_route_without_authority_fails_closed(setup): + app = Flask(__name__) + register_context_page_routes(app, service=setup[0]) + assert app.test_client().get("/v1/context/pages/cp_fixture").status_code == 503 + + +def test_additive_migration_preserves_old_tables(): + db = sqlite3.connect(":memory:") + db.execute("CREATE TABLE older (value TEXT)") + db.execute("INSERT INTO older VALUES ('retained')") + sql = (Path(__file__).parents[1] / "intelligence-migrations/0024_context_pages.sql").read_text() + db.executescript(sql) + db.executescript(sql) + assert db.execute("SELECT value FROM older").fetchone() == ("retained",) + assert db.execute("SELECT COUNT(*) FROM context_pages").fetchone() == (0,) + + +def test_tool_retrieval_validates_arguments_and_current_grant(setup): + service, _, scope = setup + meta = page(setup).pages[0] + assert service.retrieve_tool({"page_id": meta["page_id"]}, scope=scope, + retention_policy=RetentionPolicy(), granted=True)["messages"] == history()[1:-1] + for value in [None, {}, {"page_id": meta["page_id"], "principal": "alice"}]: + with pytest.raises(pages.ContextPageError) as error: + service.retrieve_tool(value, scope=scope, retention_policy=RetentionPolicy(), granted=True) + assert error.value.status == 400 + + +def test_session_limits_and_storage_failures_stop_optimization(setup): + service, store, _ = setup + body = pages.encode_group(history()[1:-1]) + store.records["older"] = (None, None, b"x" * (pages.MAX_SESSION_BYTES - len(body) + 1)) + with pytest.raises(pages.ContextPageError, match="context_session_limit") as error: + page(setup) + assert error.value.status == 413 + store.records.clear() + def unavailable(*args): + raise OSError("fixture outage") + store.put = unavailable + with pytest.raises(pages.ContextPageError) as error: + page(setup) + assert error.value.status == 503 + + +def test_transport_preserves_private_error_status(): + class Missing(Exception): + status = 404 + code = "context_page_not_found" + def call(payload): + raise Missing() + store = pages.PrivatePageStore(call) + with pytest.raises(pages.ContextPageError) as error: + store.get(pages.PageScope("alice", "session", "rev"), "fixture") + assert error.value.status == 404 and error.value.code == "context_page_not_found" + + +def test_registered_disabled_route_and_unpaged_fit(setup, monkeypatch): + service, store, scope = setup + payload = {"messages": [{"role": "user", "content": "small"}]} + result = service.page_payload(payload, scope=scope, capabilities=["multillm_context_retrieve"], + target_input_tokens=500, managed=True, retention_policy=RetentionPolicy()) + assert result.payload is payload and store.calls == 0 + monkeypatch.setenv("CONTEXT_PAGING_ENABLED", "false") + app = Flask(__name__) + register_context_page_routes(app) + assert app.test_client().get("/v1/context/pages/fixture").status_code == 404 + + +def test_protected_indices_preserve_entire_exchange(setup): + with pytest.raises(pages.ContextPageError, match="context_window_exceeded"): + page(setup, protected_indices=(4,)) + assert setup[1].calls == 0 diff --git a/tests/test_context_pages_worker.mjs b/tests/test_context_pages_worker.mjs new file mode 100644 index 00000000..9c001410 --- /dev/null +++ b/tests/test_context_pages_worker.mjs @@ -0,0 +1,268 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import { DatabaseSync } from "node:sqlite"; +import { readFileSync } from "node:fs"; +import { + ContextPageStore, TOOL_SCHEMA, pageContextMessages, retrieveContextTool, + handleContextPageRequest, handleContextPageStateRequest, +} from "../worker/context-pages-d1.mjs"; +import { estimateTokens, buildUpstreamPayload, compactionPlan, parseRoleplayPayload, prepareRoleplayContextPages, buildRoleplayMessages } from "../worker/roleplay/memory.mjs"; +import { prepareRoleplayPagingCandidates } from "../worker/roleplay/capacity.mjs"; + +function setup() { + const sqlite = new DatabaseSync(":memory:"); + sqlite.exec(readFileSync(new URL("../intelligence-migrations/0024_context_pages.sql", import.meta.url), "utf8")); + const db = { prepare(sql) { + const stmt = sqlite.prepare(sql); + return { bind(...args) { return { + async first() { return stmt.get(...args) ?? null; }, + async run() { return { success: true, meta: { changes: stmt.run(...args).changes } }; }, + }; } }; + } }; + const objects = new Map(); + const bucket = { + async put(key, body) { objects.set(key, new Uint8Array(body)); }, + async get(key) { const body = objects.get(key); return body ? { size: body.length, + async arrayBuffer() { return body.slice().buffer; } } : null; }, + async delete(key) { objects.delete(key); }, + }; + const env = { CONTEXT_PAGING_ENABLED: "true", INTELLIGENCE_DB: db, multillm_media: bucket, + MEDIA_SIGNING_SECRET: "synthetic-signing-fixture" }; + const scope = { principal: "alice", session: "session", revision: "rev-1" }; + const store = new ContextPageStore(env, { clock: () => 1000 }); + return { sqlite, objects, env, scope, store }; +} + +const messages = () => [ + { role: "system", content: "Exact directive" }, + { role: "user", content: "old 雪\n".repeat(600) }, + { role: "assistant", content: null, tool_calls: [ + { id: "a", type: "function", function: { name: "read", arguments: "{}" } }, + { id: "b", type: "function", function: { name: "read", arguments: "{}" } }, + ] }, + { role: "tool", tool_call_id: "b", content: " bytes\n\t雪 " }, + { role: "tool", tool_call_id: "a", content: "answer" }, + { role: "assistant", content: "Done" }, + { role: "user", content: "Current request" }, +]; +const options = fixture => ({ ...fixture, capabilities: ["multillm_context_retrieve"], + retentionPolicy: { enabled: false, mode: "inherit" }, managed: true, pageMessages: pageContextMessages, + inputBudget: 500, estimateTokens }); + +async function page(fixture, extra = {}) { + return pageContextMessages({ ...options(fixture), messages: messages(), ...extra }); +} + +test("exact UTF-8 tool exchange roundtrip, scoped signed handles and no hidden raw blob", async () => { + const fixture = setup(); + const plan = await page(fixture); + assert.equal(plan.pages.length, 1); + assert.deepEqual(plan.messages[0], messages()[0]); + assert.deepEqual(plan.messages.at(-1), messages().at(-1)); + assert(!JSON.stringify(plan.messages).includes("old 雪")); + assert.deepEqual(plan.tools, [TOOL_SCHEMA]); + const restored = await fixture.store.get(fixture.scope, plan.pages[0].page_id); + assert.deepEqual(restored.messages, messages().slice(1, -1)); + assert.equal(Buffer.from(restored.body_base64, "base64").toString(), JSON.stringify(messages().slice(1, -1))); + assert([...fixture.objects.keys()].every(key => key.startsWith("context-pages/"))); +}); + +test("default, empty, malformed, raw, incapable and zero retention paths do no storage", async () => { + for (const extra of [{ env: {} }, { env: { CONTEXT_PAGING_ENABLED: "" } }, + { env: { CONTEXT_PAGING_ENABLED: "invalid" } }, { managed: false }, + { capabilities: [] }, { retentionPolicy: { enabled: true, mode: "zero" } }]) { + const fixture = setup(); + const source = messages(); + const result = await page(fixture, { messages: source, inputBudget: 1, ...extra }); + assert.equal(result.messages, source); + assert.equal(fixture.objects.size, 0); + assert.equal(fixture.sqlite.prepare("SELECT COUNT(*) AS n FROM context_pages").get().n, 0); + } +}); + +test("retrieval rejects foreign principals, sessions, revisions, modified handles and expiry", async () => { + const fixture = setup(); + const plan = await page(fixture); + const id = plan.pages[0].page_id; + for (const scope of [{ ...fixture.scope, principal: "bob" }, { ...fixture.scope, session: "other" }, + { ...fixture.scope, revision: "rev-2" }]) { + await assert.rejects(fixture.store.get(scope, id), error => error.status === 404); + } + await assert.rejects(fixture.store.get(fixture.scope, id.slice(0, -1) + "!"), error => error.status === 404); + fixture.store.clock = () => 4600; + await assert.rejects(fixture.store.get(fixture.scope, id), error => error.status === 404); +}); + +test("tampered R2 content fails closed", async () => { + const fixture = setup(); + const plan = await page(fixture); + const key = [...fixture.objects.keys()][0]; + fixture.objects.set(key, new TextEncoder().encode("[]")); + await assert.rejects(fixture.store.get(fixture.scope, plan.pages[0].page_id), error => error.status === 503); +}); + +test("no-fit and incomplete exchanges fail before R2 writes", async () => { + for (const change of [value => { value.at(-1).content = "protected".repeat(1000); }, + value => value.splice(4, 1), value => { value[4].tool_call_id = "b"; }, + value => value.splice(3, 0, { role: "developer", content: "Protected exchange" }), + value => { value[2].function_call = { name: "legacy" }; }]) { + const fixture = setup(); + const input = messages(); + change(input); + await assert.rejects(page(fixture, { messages: input }), error => error.status === 413); + assert.equal(fixture.objects.size, 0); + } +}); + +test("page and atomic session byte limits, including competing writers", async () => { + const fixture = setup(); + await assert.rejects(fixture.store.put(fixture.scope, [new Uint8Array(65537)]), error => error.status === 413); + const bodies = Array.from({ length: 16 }, () => new TextEncoder().encode('"' + "x".repeat(65534) + '"')); + const competing = await Promise.allSettled([ + fixture.store.put(fixture.scope, bodies), fixture.store.put(fixture.scope, bodies), + ]); + assert.equal(competing.filter(result => result.status === "fulfilled").length, 1); + assert.equal(competing.find(result => result.status === "rejected").reason.status, 413); + assert.equal(fixture.sqlite.prepare("SELECT SUM(byte_length) AS n FROM context_pages").get().n, 1048576); + assert.equal(fixture.objects.size, 16); +}); + +test("missing table, binding or signing configuration returns real 503 JSON", async () => { + for (const missing of ["table", "multillm_media", "INTELLIGENCE_DB", "MEDIA_SIGNING_SECRET"]) { + const fixture = setup(); + if (missing === "table") fixture.sqlite.exec("DROP TABLE context_pages"); + else delete fixture.env[missing]; + const response = await handleContextPageStateRequest(new Request("http://intelligence.internal/v1/managed-state/context-pages", { + method: "POST", body: JSON.stringify({ operation: "get", scope: fixture.scope, page_id: "cp_" + "a".repeat(32) + "_" + "s".repeat(43), + retention_policy: { enabled: false, mode: "inherit" }, granted: true }), + }), fixture.env); + assert.equal(response.status, 503); + assert.equal((await response.json()).error.code, "context_paging_unavailable"); + assert.equal(fixture.objects.size, 0); + } +}); + +test("registered Worker retrieval resolves current grants and policy on every call", async () => { + const fixture = setup(); + const plan = await page(fixture); + const authority = { scope: fixture.scope, granted: true, retentionPolicy: { enabled: false, mode: "inherit" } }; + const request = new Request("https://fixture/v1/context/pages/" + plan.pages[0].page_id); + let response = await handleContextPageRequest(request, fixture.env, { store: fixture.store, authorize: async () => authority }); + assert.equal(response.status, 200); + assert.deepEqual((await response.json()).messages, messages().slice(1, -1)); + authority.granted = false; + response = await handleContextPageRequest(request, fixture.env, { store: fixture.store, authorize: async () => authority }); + assert.equal(response.status, 403); + authority.granted = true; + authority.retentionPolicy = { enabled: true, mode: "zero" }; + response = await handleContextPageRequest(request, fixture.env, { store: fixture.store, authorize: async () => authority }); + assert.equal(response.status, 403); +}); + +test("candidate paging preserves model choice and supplies only the paged upstream view", async () => { + const fixture = setup(); + const candidates = [{ provider: "opencode", model: "explicit", family: "glm", contextWindow: 650, maxOutputTokens: 100 }]; + const settings = { contextReplyReserveTokens: 100, contextSafetyTokens: 10 }; + const parsed = { stream: false, forwarded: {} }; + const prepared = await prepareRoleplayPagingCandidates(candidates, 100, settings, + { ...options(fixture), messages: messages() }); + assert.equal(prepared[0].model, "explicit"); + const payload = buildUpstreamPayload(parsed, prepared[0], messages(), settings); + assert(!JSON.stringify(payload).includes("old 雪")); + assert.deepEqual(payload.tools, [TOOL_SCHEMA]); + assert.deepEqual(payload.messages.at(-1), messages().at(-1)); + assert(!JSON.stringify(payload).includes("body_base64")); +}); + + +test("explicit tool retrieval validates schema, grant and retention", async () => { + const fixture = setup(); + const plan = await page(fixture); + const authority = { scope: fixture.scope, granted: true, store: fixture.store, + retentionPolicy: { enabled: false, mode: "inherit" } }; + const retrieved = await retrieveContextTool({ page_id: plan.pages[0].page_id }, authority); + assert.deepEqual(retrieved.messages, messages().slice(1, -1)); + for (const value of [null, {}, { page_id: plan.pages[0].page_id, principal: "alice" }]) { + await assert.rejects(retrieveContextTool(value, authority), error => error.status === 400); + } + await assert.rejects(retrieveContextTool({ page_id: plan.pages[0].page_id }, { ...authority, granted: false }), + error => error.status === 403); +}); + +test("failed R2 writes and D1 writes retain no dispatchable partial pages", async () => { + for (const failed of ["R2", "D1"]) { + const fixture = setup(); + if (failed === "R2") fixture.env.multillm_media.put = async () => { throw new Error("fixture failure"); }; + else { + const oldPrepare = fixture.env.INTELLIGENCE_DB.prepare; + fixture.env.INTELLIGENCE_DB.prepare = sql => { + if (sql.includes("INSERT INTO context_pages")) throw new Error("fixture failure"); + return oldPrepare(sql); + }; + } + await assert.rejects(page(fixture), error => error.status === 503); + assert.equal(fixture.objects.size, 0); + assert.equal(fixture.sqlite.prepare("SELECT COUNT(*) AS n FROM context_pages").get().n, 0); + } +}); + +test("missing schema is checked before creating any R2 objects", async () => { + const fixture = setup(); + fixture.sqlite.exec("DROP TABLE context_pages"); + await assert.rejects(page(fixture), error => error.status === 503); + assert.equal(fixture.objects.size, 0); +}); + +test("private put and get preserve bytes and reject zero retention before storing", async () => { + const fixture = setup(); + const body = Buffer.from(JSON.stringify(messages().slice(1, -1))).toString("base64"); + const call = values => handleContextPageStateRequest(new Request("http://intelligence.internal/v1/managed-state/context-pages", { + method: "POST", body: JSON.stringify({ scope: fixture.scope, granted: true, + retention_policy: { enabled: false, mode: "inherit" }, ...values }), + }), fixture.env); + let response = await call({ operation: "put", bodies: [body] }); + assert.equal(response.status, 200); + const id = (await response.json()).pages[0].page_id; + response = await call({ operation: "get", page_id: id }); + assert.equal(response.status, 200); + assert.equal((await response.json()).body_base64, body); + response = await call({ operation: "put", bodies: [body], retention_policy: { enabled: true, mode: "zero" } }); + assert.equal(response.status, 403); + assert.equal(fixture.objects.size, 1); +}); + +test("candidate plans reuse page bodies and bypass lossy compaction", async () => { + const fixture = setup(); + const candidate = { provider: "opencode", model: "explicit", family: "glm", contextWindow: 650, maxOutputTokens: 100 }; + const settings = { contextReplyReserveTokens: 100, contextSafetyTokens: 10, + hardInputTokens: 650, compactTriggerTokens: 1, maxStoredBytes: 10000, keepRecentMessages: 2 }; + const prepared = await prepareRoleplayPagingCandidates([candidate, { ...candidate, model: "fallback", contextWindow: 600 }], + 100, settings, { ...options(fixture), messages: messages() }); + assert.equal(prepared.length, 2); + assert.equal(fixture.objects.size, 1); + const parsed = parseRoleplayPayload({ messages: [{ role: "user", content: "continue" }], + capabilities: ["multillm_context_retrieve"], memory: { mode: "force" } }); + const state = { directives: [], memory: null }; + const plan = compactionPlan(state, parsed, messages(), settings, prepared[0].contextPlan); + assert.equal(plan.requested, false); + assert.deepEqual(plan.roleplayMessages, prepared[0].contextPlan.messages); + const roleplayPlan = await prepareRoleplayContextPages(state, parsed, messages(), + { hardInputTokens: estimateTokens(buildRoleplayMessages(state, parsed, messages(), true)) - 100 }, options(fixture)); + assert(roleplayPlan.pages.length > 0); + const restored = await fixture.store.get(fixture.scope, roleplayPlan.pages[0].page_id); + assert.deepEqual(restored.messages, messages().slice(1, -1)); +}); + +test("protected-only candidates return 413 and expired pages release the session allowance", async () => { + const fixture = setup(); + const candidate = { provider: "opencode", model: "explicit", family: "glm", contextWindow: 30, maxOutputTokens: 10 }; + await assert.rejects(prepareRoleplayPagingCandidates([candidate], 10, + { contextReplyReserveTokens: 10, contextSafetyTokens: 10 }, { ...options(fixture), messages: messages() }), + error => error.status === 413); + assert.equal(fixture.objects.size, 0); + const body = new TextEncoder().encode('"' + "x".repeat(65534) + '"'); + await fixture.store.put(fixture.scope, Array.from({ length: 16 }, () => body)); + fixture.store.clock = () => 4600; + const result = await fixture.store.put(fixture.scope, [body]); + assert.equal(result.length, 1); +}); diff --git a/worker/container-env.mjs b/worker/container-env.mjs index 1a7994db..8049955a 100644 --- a/worker/container-env.mjs +++ b/worker/container-env.mjs @@ -40,6 +40,7 @@ const DIRECT_ENV_KEYS = [ "CONNECTION_PROFILES_DB_PATH", "CONFIG_REVISION_SYNC_ENABLED", "CONFIG_SYNC_TTL_SECONDS", + "CONTEXT_PAGING_ENABLED", "GATEWAY_ALERTS_ENABLED", "GATEWAY_ALERT_WEBHOOK_ALLOWLIST", "CONFIG_SECURITY_TTL_SECONDS", diff --git a/worker/context-pages-d1.mjs b/worker/context-pages-d1.mjs new file mode 100644 index 00000000..5be6c095 --- /dev/null +++ b/worker/context-pages-d1.mjs @@ -0,0 +1,309 @@ +/** Exact context bodies in R2, signed principal/session/revision handles in D1. */ +import { RoleplayTurnError } from "./roleplay/turn-runtime.mjs"; +import { mediaMac, mediaSecret, toBase64, toBase64Url } from "./media-signing.mjs"; +import { retentionAllowsContent, retentionPolicySnapshot } from "./retention-policy.mjs"; + +export const MAX_PAGE_BYTES = 65536; +export const MAX_SESSION_BYTES = 1048576; +export const TTL_SECONDS = 3600; +export const TOOL_SCHEMA = Object.freeze({ type: "function", function: { + name: "multillm_context_retrieve", description: "Retrieve an exact stored historical context page.", + parameters: { type: "object", properties: { page_id: { type: "string" } }, + required: ["page_id"], additionalProperties: false }, +} }); +const PAGE_ID = /^cp_[a-f0-9]{32}_[A-Za-z0-9_-]{43}$/; +const encoder = new TextEncoder(); +const decoder = new TextDecoder("utf-8", { fatal: true }); +let warned = false; + +export class ContextPageError extends RoleplayTurnError { + constructor(code, status = 503) { + super(code, status, code); + this.code = code; + this.status = status; + } +} + +export function contextPagingEnabled(env = {}) { + const flag = String(env.CONTEXT_PAGING_ENABLED ?? "").trim().toLowerCase(); + if (["", "0", "false", "no", "off"].includes(flag)) return false; + if (["1", "true", "yes", "on"].includes(flag)) return true; + if (!warned) { console.warn("Invalid CONTEXT_PAGING_ENABLED; context paging disabled"); warned = true; } + return false; +} + +function checkedScope(scope) { + if (!scope || ["principal", "session", "revision"].some(key => + typeof scope[key] !== "string" || !scope[key] || encoder.encode(scope[key]).length > 256)) { + throw new ContextPageError("context_paging_authority_unavailable"); + } + return scope; +} + +export function contextPagingEligible({ env, managed, capabilities, retentionPolicy }) { + return contextPagingEnabled(env) && managed === true && Array.isArray(capabilities) + && capabilities.includes("multillm_context_retrieve") && retentionAllowsContent(retentionPolicySnapshot(retentionPolicy)); +} + +const sha256 = async body => Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", body)), + byte => byte.toString(16).padStart(2, "0")).join(""); + +function completeGroup(group) { + const pending = new Set(); + const seen = new Set(); + for (const message of group) { + if (!message || !["user", "assistant", "tool"].includes(message.role) + || ["function_call", "tool_use", "tool_uses"].some(key => Object.hasOwn(message, key))) return false; + const calls = message.tool_calls ?? []; + if (!Array.isArray(calls) || (calls.length && message.role !== "assistant") + || (pending.size && message.role !== "tool")) return false; + for (const call of calls) { + if (typeof call?.id !== "string" || !call.id || seen.has(call.id)) return false; + seen.add(call.id); + pending.add(call.id); + } + if (message.role === "tool" && !pending.delete(message.tool_call_id)) return false; + } + return pending.size === 0 && group.length > 0 && ["assistant", "tool"].includes(group.at(-1).role); +} + +function removableGroups(messages, protectedIndices = []) { + const starts = messages.flatMap((message, index) => message?.role === "user" ? [index] : []); + return starts.slice(0, -1).flatMap((start, index) => { + const end = starts[index + 1]; + return completeGroup(messages.slice(start, end)) && !protectedIndices.some(position => position >= start && position < end) + ? [{ start, end }] : []; + }); +} + +function marker(meta) { + return { role: "assistant", content: "[Stored historical context; retrieve explicitly with multillm_context_retrieve]\n" + + JSON.stringify({ page_id: meta.page_id, sha256: meta.sha256, expires_at: meta.expires_at }) }; +} + +const metadata = row => ({ page_id: row.page_id, sha256: row.sha256, + expires_at: row.expires_at, tool_schema: structuredClone(TOOL_SCHEMA) }); + +function failure(error) { + const known = error instanceof ContextPageError ? error : new ContextPageError("context_paging_unavailable"); + return Response.json({ version: 1, error: { code: known.code, message: "Context paging could not be completed." } }, + { status: known.status, headers: { "cache-control": "private, no-store" } }); +} + +export class ContextPageStore { + constructor(env, { clock = () => Date.now() / 1000 } = {}) { + this.env = env; + this.clock = clock; + } + + async ready() { + if (!contextPagingEnabled(this.env)) throw new ContextPageError("context_page_not_found", 404); + if (!this.env.INTELLIGENCE_DB || !this.env.multillm_media || !mediaSecret(this.env)) { + throw new ContextPageError("context_paging_unavailable"); + } + try { + await this.env.INTELLIGENCE_DB.prepare("SELECT page_id FROM context_pages LIMIT 1").bind().first(); + } catch { throw new ContextPageError("context_paging_unavailable"); } + } + + async _signedId(row, nonce) { + return "cp_" + nonce + "_" + toBase64Url(await mediaMac(mediaSecret(this.env), "context-page", + JSON.stringify([row.principal, row.session_hash, row.revision, row.sha256, row.expires_at, nonce]))); + } + + async put(scope, bodies) { + checkedScope(scope); + await this.ready(); + if (!Array.isArray(bodies) || !bodies.length || bodies.some(body => !(body instanceof Uint8Array) + || !body.length || body.length > MAX_PAGE_BYTES)) throw new ContextPageError("context_page_limit", 413); + const total = bodies.reduce((size, body) => size + body.length, 0); + if (total > MAX_SESSION_BYTES) throw new ContextPageError("context_session_limit", 413); + const now = Math.floor(this.clock()); + const sessionHash = await sha256(encoder.encode(scope.session)); + const principalHash = await sha256(encoder.encode(scope.principal)); + const rows = []; + const written = []; + try { + for (const body of bodies) { + const nonce = crypto.randomUUID().replaceAll("-", ""); + const row = { principal: scope.principal, session_hash: sessionHash, revision: scope.revision, + sha256: await sha256(body), byte_length: body.length, expires_at: now + TTL_SECONDS }; + row.page_id = await this._signedId(row, nonce); + row.r2_key = `context-pages/${principalHash}/${sessionHash}/${row.page_id}`; + rows.push(row); + } + for (let index = 0; index < rows.length; index += 1) { + // Record the new key first so an ambiguous put can also be cleaned up. + written.push(rows[index].r2_key); + await this.env.multillm_media.put(rows[index].r2_key, bodies[index], { + httpMetadata: { contentType: "application/json; charset=utf-8" }, + }); + } + // One statement inserts all pages or none. D1 serializes this limit check + // with the writes, including requests from other Container instances. + const result = await this.env.INTELLIGENCE_DB.prepare(` + INSERT INTO context_pages (page_id, principal, session_hash, revision, sha256, byte_length, expires_at, r2_key) + SELECT json_extract(value, '$.page_id'), json_extract(value, '$.principal'), + json_extract(value, '$.session_hash'), json_extract(value, '$.revision'), + json_extract(value, '$.sha256'), json_extract(value, '$.byte_length'), + json_extract(value, '$.expires_at'), json_extract(value, '$.r2_key') + FROM json_each(?) WHERE ? + ( + SELECT COALESCE(SUM(byte_length), 0) FROM context_pages + WHERE principal = ? AND session_hash = ? AND expires_at > ? + ) <= ?`).bind(JSON.stringify(rows), total, scope.principal, sessionHash, now, MAX_SESSION_BYTES).run(); + if (result?.success === false) throw new ContextPageError("context_paging_unavailable"); + if (result?.meta?.changes === 0) throw new ContextPageError("context_session_limit", 413); + if (result?.meta?.changes !== rows.length) throw new ContextPageError("context_paging_unavailable"); + return rows.map(metadata); + } catch (error) { + // Only newly generated keys are removed. Existing stored pages are preserved. + await Promise.allSettled(written.map(key => this.env.multillm_media.delete(key))); + throw error instanceof ContextPageError ? error : new ContextPageError("context_paging_unavailable"); + } + } + + async get(scope, pageId) { + checkedScope(scope); + await this.ready(); + if (typeof pageId !== "string" || !PAGE_ID.test(pageId)) throw new ContextPageError("context_page_not_found", 404); + try { + const sessionHash = await sha256(encoder.encode(scope.session)); + const row = await this.env.INTELLIGENCE_DB.prepare(`SELECT * FROM context_pages + WHERE page_id = ? AND principal = ? AND session_hash = ? AND revision = ? AND expires_at > ?`) + .bind(pageId, scope.principal, sessionHash, scope.revision, Math.floor(this.clock())).first(); + if (!row) throw new ContextPageError("context_page_not_found", 404); + const expected = await this._signedId(row, pageId.slice(3, 35)); + let difference = expected.length ^ pageId.length; + for (let index = 0; index < expected.length; index += 1) difference |= expected.charCodeAt(index) ^ pageId.charCodeAt(index); + if (difference) throw new ContextPageError("context_page_not_found", 404); + const key = `context-pages/${await sha256(encoder.encode(scope.principal))}/${sessionHash}/${pageId}`; + if (row.r2_key !== key || row.byte_length > MAX_PAGE_BYTES) throw new ContextPageError("context_page_integrity_failed"); + const object = await this.env.multillm_media.get(key); + if (!object || object.size !== row.byte_length) throw new ContextPageError("context_page_integrity_failed"); + const body = new Uint8Array(await object.arrayBuffer()); + if (body.length !== row.byte_length || await sha256(body) !== row.sha256) throw new ContextPageError("context_page_integrity_failed"); + const messages = JSON.parse(decoder.decode(body)); + if (!Array.isArray(messages) || !completeGroup(messages)) throw new ContextPageError("context_page_integrity_failed"); + return { ...metadata(row), body_base64: toBase64(body), messages }; + } catch (error) { + throw error instanceof ContextPageError ? error : new ContextPageError("context_paging_unavailable"); + } + } +} + +/** Preflight every replacement before persisting any body. */ +export async function pageContextMessages(options) { + const { messages, inputBudget, scope, estimateTokens, protectedIndices = [] } = options; + const original = { fit: true, messages, estimatedInputTokens: estimateTokens(messages) + + (options.tools?.length ? estimateTokens(options.tools) : 0), pages: [], tools: [] }; + if (!contextPagingEligible(options)) return original; + checkedScope(scope); + const store = options.store ?? new ContextPageStore(options.env); + await store.ready(); + if (!Number.isSafeInteger(inputBudget) || inputBudget <= 0) throw new ContextPageError("context_window_exceeded", 413); + if (original.estimatedInputTokens <= inputBudget) return original; + const tools = options.tools ?? []; + if (!Array.isArray(tools) || tools.some(tool => tool?.function?.name === "multillm_context_retrieve")) { + throw new ContextPageError("context_retrieval_tool_conflict", 400); + } + const outgoingTools = [...tools, structuredClone(TOOL_SCHEMA)]; + const now = Math.floor(store.clock()); + const groups = removableGroups(messages, protectedIndices); + const selected = []; + const replacements = new Map(); + const removed = new Set(); + let view = messages; + let total = 0; + const estimate = value => estimateTokens(value) + estimateTokens(outgoingTools); + for (const group of groups) { + const body = encoder.encode(JSON.stringify(messages.slice(group.start, group.end))); + if (body.length > MAX_PAGE_BYTES) throw new ContextPageError("context_page_limit", 413); + total += body.length; + if (total > MAX_SESSION_BYTES) throw new ContextPageError("context_session_limit", 413); + selected.push({ ...group, body }); + replacements.set(group.start, marker({ page_id: "cp_" + "0".repeat(32) + "_" + "s".repeat(43), + sha256: await sha256(body), expires_at: now + TTL_SECONDS })); + for (let index = group.start + 1; index < group.end; index += 1) removed.add(index); + view = messages.flatMap((message, index) => removed.has(index) ? [] : [replacements.get(index) ?? message]); + if (estimate(view) <= inputBudget) break; + } + if (!selected.length || estimate(view) > inputBudget) throw new ContextPageError("context_window_exceeded", 413); + const cache = options.pageCache ?? new Map(); + const keys = await Promise.all(selected.map(async group => JSON.stringify([scope, await sha256(group.body)]))); + const missing = selected.flatMap((group, index) => cache.has(keys[index]) ? [] : [{ ...group, key: keys[index] }]); + const created = missing.length ? await store.put(scope, missing.map(group => group.body)) : []; + if (!Array.isArray(created) || created.length !== missing.length) throw new ContextPageError("context_page_integrity_failed"); + missing.forEach((group, index) => cache.set(group.key, created[index])); + const pages = keys.map(key => cache.get(key)); + if (!Array.isArray(pages) || pages.length !== selected.length) throw new ContextPageError("context_page_integrity_failed"); + for (let index = 0; index < selected.length; index += 1) replacements.set(selected[index].start, marker(pages[index])); + view = messages.flatMap((message, index) => removed.has(index) ? [] : [replacements.get(index) ?? message]); + if (estimate(view) > inputBudget) throw new ContextPageError("context_window_exceeded", 413); + return { fit: true, messages: view, estimatedInputTokens: estimate(view), pages, tools: outgoingTools }; +} + +/** Only explicit calls retrieve content; this never dispatches or replays generation. */ +export async function retrieveContextTool(arguments_, { scope, granted, retentionPolicy, store }) { + if (!arguments_ || Object.keys(arguments_).length !== 1 || !Object.hasOwn(arguments_, "page_id")) { + throw new ContextPageError("invalid_context_retrieve", 400); + } + if (granted !== true || !retentionAllowsContent(retentionPolicySnapshot(retentionPolicy))) throw new ContextPageError("context_page_forbidden", 403); + return store.get(scope, arguments_.page_id); +} + +export async function handleContextPageRequest(request, env, { authorize, store = new ContextPageStore(env) } = {}) { + const match = /^\/v1\/context\/pages\/([^/]+)$/.exec(new URL(request.url).pathname); + if (!match) return null; + try { + if (!contextPagingEnabled(env)) throw new ContextPageError("context_page_not_found", 404); + if (request.method !== "GET") throw new ContextPageError("method_not_allowed", 405); + if (typeof authorize !== "function") throw new ContextPageError("context_paging_authority_unavailable"); + const authority = await authorize(request); + const result = await retrieveContextTool({ page_id: match[1] }, { ...authority, store }); + return Response.json(result, { headers: { "cache-control": "private, no-store" } }); + } catch (error) { return failure(error); } +} + +/** Private Container calls are reachable only through the authenticated state dispatcher. */ +export async function handleContextPageStateRequest(request, env) { + const url = new URL(request.url); + if (url.origin !== "http://intelligence.internal" || url.pathname !== "/v1/managed-state/context-pages" + || url.search || url.hash || url.username || url.password || request.method !== "POST") return failure(new ContextPageError("invalid_store_target", 400)); + try { + if (!contextPagingEnabled(env)) throw new ContextPageError("context_page_not_found", 404); + const reader = request.body?.getReader(); + if (!reader) throw new ContextPageError("invalid_context_operation", 400); + const chunks = []; + let size = 0; + while (true) { + const { value, done } = await reader.read(); + if (done) break; + size += value.length; + if (size > 2 * MAX_SESSION_BYTES) { + await reader.cancel(); + throw new ContextPageError("context_session_limit", 413); + } + chunks.push(value); + } + const input = new Uint8Array(size); + let offset = 0; + for (const chunk of chunks) { input.set(chunk, offset); offset += chunk.length; } + const body = JSON.parse(decoder.decode(input)); + const policy = retentionPolicySnapshot(body.retention_policy); + if (body.granted !== true || !retentionAllowsContent(policy)) throw new ContextPageError("context_page_forbidden", 403); + const store = new ContextPageStore(env); + if (body.operation === "get") { + return Response.json(await store.get(body.scope, body.page_id), { headers: { "cache-control": "private, no-store" } }); + } + if (body.operation !== "put" || !Array.isArray(body.bodies)) throw new ContextPageError("invalid_context_operation", 400); + const bodies = body.bodies.map(value => { + if (typeof value !== "string" || value.length > Math.ceil(MAX_PAGE_BYTES / 3) * 4 + || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) throw new ContextPageError("context_page_limit", 413); + const decoded = Uint8Array.from(atob(value), char => char.charCodeAt(0)); + const group = JSON.parse(decoder.decode(decoded)); + if (!Array.isArray(group) || !completeGroup(group)) throw new ContextPageError("invalid_context_messages", 400); + return decoded; + }); + return Response.json({ version: 1, pages: await store.put(body.scope, bodies) }); + } catch (error) { return failure(error); } +} diff --git a/worker/d1-schema.mjs b/worker/d1-schema.mjs index 366c2e78..5d31343f 100644 --- a/worker/d1-schema.mjs +++ b/worker/d1-schema.mjs @@ -10,7 +10,7 @@ export const REQUIRED_D1_TABLES = Object.freeze(["intelligence_policy", "intelli "usage_events", "usage_daily", "usage_batches", "media_jobs", "media_job_items", "shadow_eval_samples", "shadow_eval_results", "shadow_eval_config", "shadow_eval_policy_backups", "prompt_templates", - "config_snapshot_revisions", "config_snapshots", "config_snapshot_applications", "control_revisions", "tool_grants", "generation_cache", "usage_reservation_budgets", "usage_reservations", "usage_reservation_transitions", "session_tiers", "gateway_alert_rules", "gateway_alert_events", "managed_idempotency"]); + "config_snapshot_revisions", "config_snapshots", "config_snapshot_applications", "control_revisions", "tool_grants", "generation_cache", "usage_reservation_budgets", "usage_reservations", "usage_reservation_transitions", "session_tiers", "gateway_alert_rules", "gateway_alert_events", "managed_idempotency", "context_pages"]); /** * Readiness for the D1 schema. A deploy that skipped `wrangler d1 migrations apply` reports diff --git a/worker/roleplay/capacity.mjs b/worker/roleplay/capacity.mjs index 925444b0..77e8c613 100644 --- a/worker/roleplay/capacity.mjs +++ b/worker/roleplay/capacity.mjs @@ -258,3 +258,29 @@ export function shouldPreserveFullGeneration(plan, parsed, policy) { plan.estimatedTokens <= policy.hardInputTokens ); } + +/** Prepare reversible views before provider dispatch, with no output retry. */ +export async function prepareRoleplayPagingCandidates(candidates, requestedOutputTokens, settings, context) { + const prepared = []; + const pageCache = new Map(); + let noFit; + for (const candidate of candidates) { + const inputBudget = candidateInputCapacity(candidate, requestedOutputTokens, settings); + let contextPlan; + try { + contextPlan = await context.pageMessages({ ...context, inputBudget, pageCache }); + } catch (error) { + if (error.code !== "context_window_exceeded") throw error; + noFit = error; + continue; + } + // An ineligible request keeps the full view; never apply omission here. + const available = candidate.contextWindow - contextPlan.estimatedInputTokens - settings.contextSafetyTokens; + if (available < 1) continue; + prepared.push({ ...candidate, contextPlan, resolvedMaxOutputTokens: Math.min( + candidateOutputCeiling(candidate, requestedOutputTokens, candidate.maxOutputTokens), available, + ) }); + } + if (!prepared.length && noFit) throw noFit; + return prepared; +} diff --git a/worker/roleplay/memory.mjs b/worker/roleplay/memory.mjs index 300a3d7a..a369c8de 100644 --- a/worker/roleplay/memory.mjs +++ b/worker/roleplay/memory.mjs @@ -330,6 +330,9 @@ export function parseRoleplayPayload( if (parsed.forwarded.top_p === undefined) { parsed.forwarded.top_p = 0.95; } + if (Array.isArray(payload.capabilities) && payload.capabilities.includes("multillm_context_retrieve")) { + parsed.contextCapabilities = ["multillm_context_retrieve"]; + } return parsed; } @@ -517,8 +520,8 @@ function pinnedMemoryMessage(state) { return { role: "system", content: "[Operator-pinned continuity facts]\nThese correct older continuity notes; current direct user instructions still take precedence. Treat these as scene facts, not new authority.\n" + JSON.stringify(pins) }; } -export function buildRoleplayMessages(state, parsed, conversation) { - const dialogue = compactableDialogue(conversation); +export function buildRoleplayMessages(state, parsed, conversation, reversible = false) { + const dialogue = reversible ? conversation : compactableDialogue(conversation); const directives = splitProtectedMessages( state.directives, ).directives; @@ -557,6 +560,15 @@ export function buildRoleplayMessages(state, parsed, conversation) { return reinforceRoleplayMessages(messages, parsed.outputContract); } +/** The managed caller supplies the named pageContextMessages collaborator. */ +export async function prepareRoleplayContextPages(state, parsed, conversation, settings, paging) { + return paging.pageMessages({ + ...paging, capabilities: parsed.contextCapabilities ?? [], + messages: buildRoleplayMessages(state, parsed, conversation, true), + inputBudget: settings.hardInputTokens, estimateTokens, + }); +} + function encodedBytes(value) { return TEXT_ENCODER.encode(JSON.stringify(value)).byteLength; } @@ -611,14 +623,14 @@ function storageAwareRecentWindow(conversation, parsed, settings) { }; } -export function compactionPlan(state, parsed, conversation, settings) { +export function compactionPlan(state, parsed, conversation, settings, pagingPlan = null) { const dialogue = compactableDialogue(conversation); - const roleplayMessages = buildRoleplayMessages( + const roleplayMessages = pagingPlan?.messages ?? buildRoleplayMessages( state, parsed, dialogue, ); - const estimatedTokens = estimateTokens(roleplayMessages); + const estimatedTokens = pagingPlan?.estimatedInputTokens ?? estimateTokens(roleplayMessages); const compactableTokens = estimateTokens({ memory: parsed.memory.mode === "off" ? null : state.memory, dialogue, @@ -639,7 +651,7 @@ export function compactionPlan(state, parsed, conversation, settings) { parsed.memory.mode !== "off" && forced; - if (!requested) { + if (!requested || pagingPlan) { return { requested: false, forced: false, @@ -854,10 +866,13 @@ export function buildUpstreamPayload( ) { const payload = { model: candidate.upstreamModel ?? candidate.model, - messages, + messages: candidate.contextPlan?.pages?.length ? candidate.contextPlan.messages : messages, stream: parsed.stream, ...parsed.forwarded, }; + if (candidate.contextPlan?.pages?.length) { + payload.tools = candidate.contextPlan.tools; + } if (Number.isSafeInteger(candidate.resolvedMaxOutputTokens)) { payload.max_tokens = candidate.resolvedMaxOutputTokens; }