context-engineering-core 0.12.0__tar.gz → 0.12.1__tar.gz

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/CHANGELOG.md

@@ -3,7 +3,21 @@
 Earlier versions (0.1.0–0.9.6) are documented in `docs/C01_REPORT.md` through
 `docs/C10_STORAGE_ACL_REPORT.md` and preserved as wheels under `archives/`.
 
-## 0.12.0 — 2026-10-31 (unreleased)
+## 0.12.1 — 2026-10-31 (unreleased)
+
+### Changed (performance only; output identical)
+- Budget fit checks compute only the request's estimated token count
+  (`TiktokenCounter.estimate_tokens`), skipping per-message counts and hashing that
+  are only reported. Custom counters keep the full `count_request` path.
+- WINDOW candidates skip their own token count; per-turn JSON is reused.
+- Window planning (run by RETRIEVE, WINDOW and SUMMARIZE) and history digests are
+  memoized by value (bounded; built-in counter/serializer only).
+- All-layers median on the 100-turn benchmark: 95 → 67 ms at 900 tokens and
+  208 → 80 ms at 3000 tokens. All 310 strategy-benchmark assemblies (31 facts x 5
+  strategies x 2 budgets) are byte-identical to 0.12.0. 0.12.0 wheel/freeze archived
+  in `archives/c12-latency-0121/`.
+
+## 0.12.0 — 2026-10-31 (PyPI)
 
 ### Added
 - `context_engine.adapters`: `openai_chat`, `anthropic_messages`,

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: context-engineering-core
-Version: 0.12.0
+Version: 0.12.1
 Summary: Provider-independent context layers, source contracts, and token budget accounting
 Project-URL: Homepage, https://github.com/Nandu1729/Context-Engine
 Project-URL: Repository, https://github.com/Nandu1729/Context-Engine

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "context-engineering-core"
-version = "0.12.0"
+version = "0.12.1"
 description = "Provider-independent context layers, source contracts, and token budget accounting"
 readme = "README.md"
 license = "Apache-2.0"

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/src/context_engine/__init__.py

@@ -1,6 +1,6 @@
 """Core contracts. Importing this package performs no configuration or network I/O."""
 
-__version__ = "0.12.0"
+__version__ = "0.12.1"
 
 
 def __getattr__(name):

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/src/context_engine/evaluation/data/freeze.json

@@ -7,7 +7,7 @@
     "summary_fixture": "b3c1b76bb330b52493e5150647747bad77d5de3a55d05d032bb5703be1c70196"
   },
   "runtime": {
-    "code_hash": "59eeb4d28e6b3106a18317d5b6acee255f0b22d5e5143e3e7bb74b1146a39ff4",
+    "code_hash": "c3d4bfbdad58327eb09a763ae398fd97277e33339ce00cfb5395b2615f2d269f",
     "dependencies": {
       "certifi": "2026.10.23",
       "charset-normalizer": "3.5.1",
@@ -19,7 +19,7 @@
       "tiktoken": "0.14.0",
       "urllib3": "2.8.0"
     },
-    "package_version": "0.12.0",
+    "package_version": "0.12.1",
     "python": "3.12.13"
   },
   "schema_version": 1

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/src/context_engine/layers/common.py

@@ -1,7 +1,9 @@
 """Shared rendering/accounting primitives used by layers and the public pipeline."""
 
 import hashlib
+from collections import OrderedDict
 from dataclasses import asdict, replace
+from functools import lru_cache
 
 from ..context import ContextCarrier, LayerDiagnostic
 from ..errors import LayerStateError
@@ -15,7 +17,7 @@ from ..models import (
     Turn,
     canonical_json,
 )
-from ..tokens import TokenCounter
+from ..tokens import CanonicalChatSerializer, TiktokenCounter, TokenCounter, estimated_tokens
 from ..work import raise_if_cancelled
 
 ORDER = tuple(BlockKind)
@@ -23,6 +25,12 @@ OPTIONAL = (BlockKind.SUMMARY, BlockKind.WINDOW, BlockKind.RETRIEVED)
 
 
 def history_digest(turns: tuple[Turn, ...]) -> str:
+    # Turns are immutable values, so equal histories share one cached digest.
+    return _history_digest(tuple(turns))
+
+
+@lru_cache(maxsize=256)
+def _history_digest(turns: tuple[Turn, ...]) -> str:
     values = [
         (asdict(t.scope), t.turn_id, t.revision, t.timestamp.isoformat(), t.content_hash)
         for t in turns
@@ -101,18 +109,21 @@ def set_block(
     )
 
 
+@lru_cache(maxsize=4096)
+def _turn_json(turn) -> str:
+    return canonical_json({"turn": turn.turn_id, "messages": [m.to_wire() for m in turn.messages]})
+
+
 def window_block(
-    context: ContextCarrier, ids: tuple[str, ...], counter: TokenCounter
+    context: ContextCarrier, ids: tuple[str, ...], counter: TokenCounter, *, count: bool = True
 ) -> ContextBlock:
+    """`count=False` skips the block's own token count (planning-only candidates)."""
     selected = [t for t in context.working_turns if t.turn_id in ids]
-    content = (
-        canonical_json(
-            [{"turn": t.turn_id, "messages": [m.to_wire() for m in t.messages]} for t in selected]
-        )
-        if selected
-        else ""
+    # Identical to canonical_json of the list: compact separators, per-item sorted keys.
+    content = "[" + ",".join(_turn_json(t) for t in selected) + "]" if selected else ""
+    return ContextBlock(
+        BlockKind.WINDOW, content, text_tokens=counter.count_text(content) if count else None
     )
-    return ContextBlock(BlockKind.WINDOW, content, text_tokens=counter.count_text(content))
 
 
 def incremental_cost(context: ContextCarrier, block: ContextBlock, counter: TokenCounter) -> int:
@@ -121,8 +132,7 @@ def incremental_cost(context: ContextCarrier, block: ContextBlock, counter: Toke
     )
     return max(
         0,
-        counter.count_request(request).estimated_tokens
-        - context.plan.required_estimate.estimated_tokens,
+        estimated_tokens(counter, request) - context.plan.required_estimate.estimated_tokens,
     )
 
 
@@ -135,24 +145,64 @@ def fits_block(
     # RETRIEVE runs first but must leave the exact planned WINDOW viable.
     if context.window_planned and block.kind != BlockKind.WINDOW:
         blocks = tuple(b for b in blocks if b.kind != BlockKind.WINDOW) + (
-            window_block(context, context.plan.window_turn_ids, counter),
+            window_block(context, context.plan.window_turn_ids, counter, count=False),
         )
     request = render_request(blocks, context.question, context.required_request.tools)
-    return counter.count_request(request).estimated_tokens <= context.plan.input_allowance
+    return estimated_tokens(counter, request) <= context.plan.input_allowance
 
 
-def plan_window(context: ContextCarrier, counter: TokenCounter) -> ContextCarrier:
-    require_prepared(context, counter)
+_WINDOW_MEMO: OrderedDict = OrderedDict()
+_WINDOW_MEMO_SIZE = 64
+
+
+def _window_key(context: ContextCarrier, counter: TokenCounter):
+    """Every input the WINDOW scan reads; None (no memo) for custom counters/serializers."""
+    if (
+        type(counter) is not TiktokenCounter
+        or type(counter.serializer) is not CanonicalChatSerializer
+    ):
+        return None
+    return (
+        counter.config,
+        tuple(context.working_turns),
+        required_blocks(context),
+        context.question,
+        context.required_request.tools,
+        context.plan.window_tokens,
+        context.plan.required_estimate.estimated_tokens,
+    )
+
+
+def _scan_window(context: ContextCarrier, counter: TokenCounter) -> tuple[str, ...]:
     selected: tuple[str, ...] = ()
     for turn in reversed(context.working_turns):
         raise_if_cancelled(context.cancellation)
         candidate = (turn.turn_id,) + selected
         if (
-            incremental_cost(context, window_block(context, candidate, counter), counter)
+            incremental_cost(
+                context, window_block(context, candidate, counter, count=False), counter
+            )
             > context.plan.window_tokens
         ):
             break
         selected = candidate
+    return selected
+
+
+def plan_window(context: ContextCarrier, counter: TokenCounter) -> ContextCarrier:
+    require_prepared(context, counter)
+    # RETRIEVE, WINDOW and SUMMARIZE each re-plan the same inputs; the scan is pure.
+    key = _window_key(context, counter)
+    if key is None or key not in _WINDOW_MEMO:
+        selected = _scan_window(context, counter)
+        if key is not None:
+            _WINDOW_MEMO[key] = selected
+            if len(_WINDOW_MEMO) > _WINDOW_MEMO_SIZE:
+                _WINDOW_MEMO.popitem(last=False)
+    else:
+        raise_if_cancelled(context.cancellation)
+        _WINDOW_MEMO.move_to_end(key)
+        selected = _WINDOW_MEMO[key]
     if context.window_planned:
         if selected != context.plan.window_turn_ids:
             raise LayerStateError("Stored WINDOW membership differs from shared planner")

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/src/context_engine/pipeline.py

@@ -27,7 +27,7 @@ from .models import (
     canonical_json,
     freeze_sequence,
 )
-from .tokens import TiktokenCounter, TokenCounter, TokenEstimate
+from .tokens import TiktokenCounter, TokenCounter, TokenEstimate, estimated_tokens
 from .work import Cancellation, raise_if_cancelled, validate_cancellation
 
 
@@ -245,7 +245,7 @@ def _finalize(
 def _block_accounting(blocks, question, tools, counter, estimate):
     empty_question = replace(question, content="")
     running: tuple[ContextBlock, ...] = ()
-    previous = counter.count_request(render_request((), empty_question, tools)).estimated_tokens
+    previous = estimated_tokens(counter, render_request((), empty_question, tools))
     base = previous
     result = []
     by_kind = {b.kind: b for b in blocks}
@@ -254,9 +254,7 @@ def _block_accounting(blocks, question, tools, counter, estimate):
         current_question = question if kind == BlockKind.QUESTION else empty_question
         if kind != BlockKind.QUESTION:
             running += (item,)
-        current = counter.count_request(
-            render_request(running, current_question, tools)
-        ).estimated_tokens
+        current = estimated_tokens(counter, render_request(running, current_question, tools))
         content = question.content if kind == BlockKind.QUESTION else item.content
         result.append(
             BlockUsage(

{context_engineering_core-0.12.0 → context_engineering_core-0.12.1}/src/context_engine/tokens.py

@@ -152,6 +152,14 @@ class TiktokenCounter:
             return _cached_count(self.config.encoding_name, text)
         return len(self._encoding.encode_ordinary(text))
 
+    def estimate_tokens(self, request: ChatRequest) -> int:
+        """`count_request(request).estimated_tokens` without the reporting-only parts."""
+        serialized = self.count_text(self.serializer.serialize(request))
+        return math.ceil(
+            (serialized + self.config.adapter_overhead_tokens)
+            * Fraction(str(self.config.calibration_factor))
+        )
+
     def count_request(self, request: ChatRequest) -> TokenEstimate:
         rendered = self.serializer.serialize(request)
         return TokenEstimate(
@@ -169,3 +177,9 @@ class TiktokenCounter:
             serializer_name=self.serializer.name,
             request_fingerprint=hashlib.sha256(rendered.encode("utf-8")).hexdigest(),
         )
+
+
+def estimated_tokens(counter: TokenCounter, request: ChatRequest) -> int:
+    """Budget-check estimate; custom counters without `estimate_tokens` use the full count."""
+    fast = getattr(counter, "estimate_tokens", None)
+    return fast(request) if fast is not None else counter.count_request(request).estimated_tokens