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 4dc35c96..e3f2cec5 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 tests/test_wave4_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 tests/test_wave4_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 3bc276f1..6254b8e3 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; }