mnemonic-proxy 0.3.8__tar.gz → 0.3.9__tar.gz

{mnemonic_proxy-0.3.8/mnemonic_proxy.egg-info → mnemonic_proxy-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnemonic-proxy
-Version: 0.3.8
+Version: 0.3.9
 Summary: Transparent proxy that lets local coding agents work for hours: verbatim archive, structured recall, segments with handoff notes, saved engine state.
 Author: Maurizio Verde
 License-Expression: MIT
@@ -1057,6 +1057,21 @@ Reports (Italian): [DS4-LONG-RESULT.md](https://github.com/lastreload/mnemonic-p
 
 ## Configuration
 
+Output limits in managed mode: `max_completion_tokens` takes precedence over `max_tokens` when both are supplied;
+without either field, `default_response` is used (16384 by default). These values are ceilings, not a reason to
+switch segments. After masking and any necessary switch, the proxy caps the response to
+`window - estimated_prompt - reserve - 8` and sends the reduced limit to the engine (both fields are synchronized
+when present). The final window guard may reduce it further for its margin and estimate slack; it refuses a
+prompt with no space for even one generated token. Exact guarantees require `--tokenizer`; otherwise counts are
+estimates, not proof of the engine's actual token usage.
+
+A genuinely large prompt still triggers a segment switch when there is not enough room for a useful response:
+`max(response_floor, min(requested_output, default_response))`, bounded to at least one token and at most a quarter
+of the window. A floor never raises the actual output ceiling requested by the client. Every reduction produces
+`response_clamped` in `journal.jsonl` (requested and sent limits, prompt estimate, window and reserve), plus one
+warning per conversation in the process log, remembered across restarts. No new option is required; for example,
+a client ceiling of 120000 in a 131072 window no longer causes a switch on every short turn.
+
 `--config` takes a JSON object with any field of `ctxproxy.core.Config`. Defaults below are the real ones in the
 code. Most features are off by default so that 0.1 behaviour is unchanged; the last column is what we recommend
 with an engine that has saved state (`examples/config.example.json` plus the options the benchmarks above support).
@@ -1073,7 +1088,7 @@ with an engine that has saved state (`examples/config.example.json` plus the opt
 | `slot_dir` | "" | the engine's `--slot-save-path` folder, same host (anchor cleanup, autosave, `kv_archive`) | set |
 | `segments_enabled`, `tail_max`, `notes_max_tokens` | true, 24000, 8192 | segment switch with handoff notes | true, 24000, **12288** |
 | `slot_save` / `seal_experimental` | false / false | save the old segment to disk before switching (saved state) | **true / true** |
-| `response_floor` | 0 | minimum response size assumed in the window check | **16384** |
+| `response_floor` | 0 | minimum useful response budget for segment switching (bounded to a quarter of the window) | **16384** |
 | `inject_recall`, `max_recall_rounds`, `recall_max_tokens` | true, 4, 6000 | the `recall` tool | default |
 | `recall_tool_name` / `tools_tool_name` | "recall" / "tools" | names of the proxy's tools for new conversations | default |
 | `prompt_language` | "en" | language of the texts the proxy writes into the prompt, for NEW conversations: `"en"` or `"it"`; stored per conversation at first use; conversations from before 0.3.1 stay Italian | default |

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9}/README.md

@@ -1023,6 +1023,21 @@ Reports (Italian): [DS4-LONG-RESULT.md](https://github.com/lastreload/mnemonic-p
 
 ## Configuration
 
+Output limits in managed mode: `max_completion_tokens` takes precedence over `max_tokens` when both are supplied;
+without either field, `default_response` is used (16384 by default). These values are ceilings, not a reason to
+switch segments. After masking and any necessary switch, the proxy caps the response to
+`window - estimated_prompt - reserve - 8` and sends the reduced limit to the engine (both fields are synchronized
+when present). The final window guard may reduce it further for its margin and estimate slack; it refuses a
+prompt with no space for even one generated token. Exact guarantees require `--tokenizer`; otherwise counts are
+estimates, not proof of the engine's actual token usage.
+
+A genuinely large prompt still triggers a segment switch when there is not enough room for a useful response:
+`max(response_floor, min(requested_output, default_response))`, bounded to at least one token and at most a quarter
+of the window. A floor never raises the actual output ceiling requested by the client. Every reduction produces
+`response_clamped` in `journal.jsonl` (requested and sent limits, prompt estimate, window and reserve), plus one
+warning per conversation in the process log, remembered across restarts. No new option is required; for example,
+a client ceiling of 120000 in a 131072 window no longer causes a switch on every short turn.
+
 `--config` takes a JSON object with any field of `ctxproxy.core.Config`. Defaults below are the real ones in the
 code. Most features are off by default so that 0.1 behaviour is unchanged; the last column is what we recommend
 with an engine that has saved state (`examples/config.example.json` plus the options the benchmarks above support).
@@ -1039,7 +1054,7 @@ with an engine that has saved state (`examples/config.example.json` plus the opt
 | `slot_dir` | "" | the engine's `--slot-save-path` folder, same host (anchor cleanup, autosave, `kv_archive`) | set |
 | `segments_enabled`, `tail_max`, `notes_max_tokens` | true, 24000, 8192 | segment switch with handoff notes | true, 24000, **12288** |
 | `slot_save` / `seal_experimental` | false / false | save the old segment to disk before switching (saved state) | **true / true** |
-| `response_floor` | 0 | minimum response size assumed in the window check | **16384** |
+| `response_floor` | 0 | minimum useful response budget for segment switching (bounded to a quarter of the window) | **16384** |
 | `inject_recall`, `max_recall_rounds`, `recall_max_tokens` | true, 4, 6000 | the `recall` tool | default |
 | `recall_tool_name` / `tools_tool_name` | "recall" / "tools" | names of the proxy's tools for new conversations | default |
 | `prompt_language` | "en" | language of the texts the proxy writes into the prompt, for NEW conversations: `"en"` or `"it"`; stored per conversation at first use; conversations from before 0.3.1 stay Italian | default |

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9}/ctxproxy/__init__.py

@@ -5,4 +5,4 @@ Verbatim archive, structured recall, segments with handoff notes, saved engine s
 (llama-server), ds4-server or any OpenAI-compatible engine; speaks Chat Completions, Anthropic Messages and OpenAI Responses.
 """
 
-__version__ = "0.3.8"
+__version__ = "0.3.9"

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9}/ctxproxy/core.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 import dataclasses
 import hashlib
 import json
+import logging
 import os
 import re
 import sqlite3
@@ -985,6 +986,7 @@ class Prepared:
     masked: int
     masked_tokens: int            # token ARCHIVIATI dei pezzi nascosti (testo originale)
     masked_saved: int = 0         # riduzione fisica misurata (somma dei Δ dei pacchetti)
+    response_limit: int | None = None  # generation ceiling after prepare; final window guard may lower it further
     catalog: dict = dataclasses.field(default_factory=dict)      # strumenti caricabili con lo strumento tools
     invalidated: dict = dataclasses.field(default_factory=dict)  # token di cache invalidati e causa
     recall_name: str = RECALL_NAME     # nomi degli strumenti del proxy in questa conversazione
@@ -1306,10 +1308,13 @@ class Manager:
                     events.extend(self._anchor(conv, seg or 0, req, phys, origin, per, tools, ev, upstream))
 
         # ---- livello 2: segmenti ----
-        resp = int(req.get("max_tokens") or req.get("max_completion_tokens") or cfg.default_response)
-        if resp <= 0:
-            resp = cfg.default_response
-        resp = max(resp, cfg.response_floor)
+        requested = int(req.get("max_completion_tokens") or req.get("max_tokens") or cfg.default_response)
+        if requested <= 0:
+            requested = cfg.default_response
+        # A client's output ceiling is not evidence that the prompt needs a new segment.
+        # Keep a useful generation budget, not the entire requested maximum, for switching.
+        floor = max(1, min(max(cfg.response_floor, min(requested, cfg.default_response)), cfg.window // 4))
+        resp = max(floor, min(requested, cfg.window - est - cfg.reserve - 8))
         if cfg.segments_enabled and est + resp + cfg.reserve + 8 > cfg.window and upstream is not None:
             ev = self._switch(conv, req, msgs, hs, phys, origin, per, tools, seg or 0, upstream, est, resp)
             events.extend(ev)
@@ -1327,6 +1332,21 @@ class Manager:
                     phys, origin = self.build(msgs, hs, start, notes_msg, pins_msg)
                     est, per = self.estimate(phys, tools)
 
+        # Recompute after masking, segmentation and auto-recall. Never raise a client's ceiling.
+        room = cfg.window - est - cfg.reserve - 8
+        response_limit = max(1, min(requested, room))
+        if response_limit < requested:
+            events.append(self.journal.log("response_clamped", conv=conv, requested=requested,
+                                           max_tokens=response_limit, prompt=est, window=cfg.window,
+                                           reserve=cfg.reserve, floor=floor,
+                                           message="Output limit reduced to available context; no output-only switch"))
+            warning_key = "response_clamp_warned:" + conv
+            if not self.store.kv_get(warning_key):
+                logging.getLogger(__name__).warning(
+                    "mnemonic-proxy conversation %s: requested output %d reduced to %d tokens to fit window %d",
+                    conv, requested, response_limit, cfg.window)
+                self.store.kv_set(warning_key, "1")
+
         masks = self.store.masks_for(hs + [h + THINK_SUFFIX for h in hs] + [h + ARGS_SUFFIX for h in hs]
                                      + [h + DROP_SUFFIX for h in hs])
         inv = self._invalidation(conv, phys, tools, per, est, events)
@@ -1344,7 +1364,7 @@ class Manager:
                     else rec["ratio_planned"]
                 self.journal.log("mask_cost", **rec)
         return Prepared(conv=conv, messages=phys, tools=tools, hs=hs, seg=seg or 0, est_tokens=est,
-                        virtual_tokens=virtual, events=events, masked=len(masks),
+                        virtual_tokens=virtual, events=events, masked=len(masks), response_limit=response_limit,
                         masked_tokens=sum(n for _, n in masks.values()),
                         masked_saved=self.store.masks_saved(list(masks)), catalog=catalog,
                         invalidated=inv, recall_name=self.rn, tools_name=self.tn, lang=self.lang,

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9}/ctxproxy/server.py

@@ -32,7 +32,7 @@ from .upstream import Upstream, UpstreamError
 from .window import (ALL_BANDS, CALL_ALLOWANCE, FINAL_NOTE_EN, FINAL_NOTE_IT, LIMIT_NOTE_EN, LIMIT_NOTE_IT,
                      NO_ROOM_EN, NO_ROOM_IT, NOTICE_MIN, RESULT_MIN, RESULT_R, SEARCH_BANDS, SearchState, WindowGuard,
                      _text as _txt, clean, conclusion, idents, pieces, remove_piece, removal_entry, removal_order,
-                     sources_from_meta)
+                     set_mt, sources_from_meta)
 
 LIMIT_MSG = ("{rn}: limite di ricerche raggiunto per questa risposta. Non chiamare più "
              "{rn}: rispondi ora con le informazioni già recuperate (o di' che non le hai).")
@@ -212,6 +212,8 @@ class Proxy:
         recalls, recall_logs = [], []
         strip_c, strip_r = [], []
         body = {k: v for k, v in req.items() if k not in ("messages", "tools", "stream", "stream_options")}
+        if p.response_limit is not None:
+            body = set_mt(body, p.response_limit)
         resp = None
         msgs_c = req.get("messages") or []
         last_user = max((i for i, m in enumerate(msgs_c) if is_human_user(m)), default=None)

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9/mnemonic_proxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mnemonic-proxy
-Version: 0.3.8
+Version: 0.3.9
 Summary: Transparent proxy that lets local coding agents work for hours: verbatim archive, structured recall, segments with handoff notes, saved engine state.
 Author: Maurizio Verde
 License-Expression: MIT
@@ -1057,6 +1057,21 @@ Reports (Italian): [DS4-LONG-RESULT.md](https://github.com/lastreload/mnemonic-p
 
 ## Configuration
 
+Output limits in managed mode: `max_completion_tokens` takes precedence over `max_tokens` when both are supplied;
+without either field, `default_response` is used (16384 by default). These values are ceilings, not a reason to
+switch segments. After masking and any necessary switch, the proxy caps the response to
+`window - estimated_prompt - reserve - 8` and sends the reduced limit to the engine (both fields are synchronized
+when present). The final window guard may reduce it further for its margin and estimate slack; it refuses a
+prompt with no space for even one generated token. Exact guarantees require `--tokenizer`; otherwise counts are
+estimates, not proof of the engine's actual token usage.
+
+A genuinely large prompt still triggers a segment switch when there is not enough room for a useful response:
+`max(response_floor, min(requested_output, default_response))`, bounded to at least one token and at most a quarter
+of the window. A floor never raises the actual output ceiling requested by the client. Every reduction produces
+`response_clamped` in `journal.jsonl` (requested and sent limits, prompt estimate, window and reserve), plus one
+warning per conversation in the process log, remembered across restarts. No new option is required; for example,
+a client ceiling of 120000 in a 131072 window no longer causes a switch on every short turn.
+
 `--config` takes a JSON object with any field of `ctxproxy.core.Config`. Defaults below are the real ones in the
 code. Most features are off by default so that 0.1 behaviour is unchanged; the last column is what we recommend
 with an engine that has saved state (`examples/config.example.json` plus the options the benchmarks above support).
@@ -1073,7 +1088,7 @@ with an engine that has saved state (`examples/config.example.json` plus the opt
 | `slot_dir` | "" | the engine's `--slot-save-path` folder, same host (anchor cleanup, autosave, `kv_archive`) | set |
 | `segments_enabled`, `tail_max`, `notes_max_tokens` | true, 24000, 8192 | segment switch with handoff notes | true, 24000, **12288** |
 | `slot_save` / `seal_experimental` | false / false | save the old segment to disk before switching (saved state) | **true / true** |
-| `response_floor` | 0 | minimum response size assumed in the window check | **16384** |
+| `response_floor` | 0 | minimum useful response budget for segment switching (bounded to a quarter of the window) | **16384** |
 | `inject_recall`, `max_recall_rounds`, `recall_max_tokens` | true, 4, 6000 | the `recall` tool | default |
 | `recall_tool_name` / `tools_tool_name` | "recall" / "tools" | names of the proxy's tools for new conversations | default |
 | `prompt_language` | "en" | language of the texts the proxy writes into the prompt, for NEW conversations: `"en"` or `"it"`; stored per conversation at first use; conversations from before 0.3.1 stay Italian | default |

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9}/mnemonic_proxy.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ tests/test_autosave.py
 tests/test_check_kv_archive.py
 tests/test_clients.py
 tests/test_compat.py
+tests/test_dashboard.py
 tests/test_default_identity.py
 tests/test_ds4.py
 tests/test_engine_window.py
@@ -59,6 +60,7 @@ tests/test_proxy.py
 tests/test_recall2.py
 tests/test_recall_paging.py
 tests/test_recall_small_window.py
+tests/test_response_limit.py
 tests/test_router.py
 tests/test_search_keeps_evidence.py
 tests/test_setup_scripts.py

{mnemonic_proxy-0.3.8 → mnemonic_proxy-0.3.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mnemonic-proxy"
-version = "0.3.8"
+version = "0.3.9"
 description = "Transparent proxy that lets local coding agents work for hours: verbatim archive, structured recall, segments with handoff notes, saved engine state."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = "MIT"

mnemonic_proxy-0.3.9/tests/test_dashboard.py

@@ -0,0 +1,25 @@
+"""Static dashboard contracts (no browser dependency in the unit suite)."""
+import re
+import unittest
+from html.parser import HTMLParser
+from pathlib import Path
+
+
+class IdParser(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.ids = []
+
+    def handle_starttag(self, tag, attrs):
+        self.ids.extend(value for key, value in attrs if key == "id")
+
+
+class DashboardTests(unittest.TestCase):
+    def test_literal_id_references_exist(self):
+        html = (Path(__file__).resolve().parents[1] / "dashboard" / "index.html").read_text(encoding="utf-8")
+        parser = IdParser()
+        parser.feed(html)
+        refs = set(re.findall(r'\$\([\"\']([^\"\']+)[\"\']\)', html))
+        self.assertTrue(refs)
+        self.assertEqual(refs - set(parser.ids), set())
+        self.assertEqual(len(parser.ids), len(set(parser.ids)), "duplicate HTML IDs")

mnemonic_proxy-0.3.9/tests/test_response_limit.py

@@ -0,0 +1,89 @@
+"""Output ceilings must not cause repeated segment switches (DarkJezter)."""
+import copy
+from unittest.mock import patch
+
+from tests.test_proxy import Base, TOOLS
+
+
+class TestResponseLimit(Base):
+    def history(self):
+        return [{'role': 'system', 'content': 's' * 27000},
+                {'role': 'user', 'content': 'Continue.'}]
+
+    def test_high_ceiling_25_turns_and_one_warning(self):
+        msgs = self.history()
+        with patch('ctxproxy.core.logging.Logger.warning') as warn:
+            for i in range(25):
+                response, _ = self.send(msgs, max_tokens=120000)
+                msgs += [response['choices'][0]['message'], {'role': 'user', 'content': str(i)}]
+            self.assertEqual(warn.call_count, 1)
+        self.assertFalse(self.events('switch'))
+        self.assertFalse(self.events('mask'))
+        self.assertEqual(len(self.events('response_clamped')), 25)
+        self.assertEqual(len(self.events('new_conversation')), 1)
+        for body in self.eng.requests:
+            prompt = self.proxy.wguard.count_body(body)
+            self.assertLess(body['max_tokens'], 120000)
+            self.assertLessEqual(prompt + body['max_tokens'] + self.proxy.wguard.margin,
+                                 self.proxy.cfg.window)
+
+    def test_healthy_limit_unchanged(self):
+        self.send(self.history(), max_tokens=4096)
+        self.assertEqual(self.eng.requests[-1]['max_tokens'], 4096)
+        self.assertFalse(self.events('response_clamped'))
+        self.assertFalse(self.events('switch'))
+
+    def test_both_fields_follow_engine_precedence_and_input_is_unchanged(self):
+        req = {'messages': self.history(), 'tools': TOOLS, 'max_tokens': 4096,
+               'max_completion_tokens': 120000}
+        original = copy.deepcopy(req)
+        status, _, _ = self.proxy.chat(req)
+        self.assertEqual(status, 200)
+        self.assertEqual(req, original)
+        sent = self.eng.requests[-1]
+        self.assertEqual(sent['max_tokens'], sent['max_completion_tokens'])
+        self.assertLess(sent['max_tokens'], 120000)
+        self.assertFalse(self.events('switch'))
+
+    def test_small_completion_limit_wins_over_large_max_tokens(self):
+        self.send(self.history(), max_tokens=120000, max_completion_tokens=512)
+        self.assertEqual(self.eng.requests[-1]['max_completion_tokens'], 512)
+        self.assertFalse(self.events('switch'))
+
+    def test_default_budget_is_explicit(self):
+        self.proxy.chat({'messages': self.history(), 'tools': TOOLS})
+        self.assertEqual(self.eng.requests[-1]['max_tokens'], self.proxy.cfg.default_response)
+
+    def test_large_prompt_still_attempts_segment_switch(self):
+        self.proxy.cfg.mask_enabled = False
+        msgs = self.history() + [{'role': 'assistant', 'content': 'a' * 390000},
+                                 {'role': 'user', 'content': 'Continue.'}]
+        with patch.object(self.proxy.mgr, '_switch', return_value=[]) as switch:
+            self.proxy.mgr.prepare({'messages': msgs, 'max_tokens': 120000}, upstream=self.proxy.up)
+        switch.assert_called_once()
+
+    def test_floor_never_raises_client_ceiling(self):
+        self.proxy.cfg.response_floor = 16384
+        self.send(self.history(), max_tokens=128)
+        self.assertEqual(self.eng.requests[-1]['max_tokens'], 128)
+
+    def test_clamping_without_segments_and_warning_survives_manager_restart(self):
+        from ctxproxy.core import Manager
+        self.proxy.cfg.segments_enabled = False
+        req = {'messages': self.history(), 'max_completion_tokens': 120000}
+        with patch('ctxproxy.core.logging.Logger.warning') as warn:
+            prepared = self.proxy.mgr.prepare(req, upstream=self.proxy.up)
+            replacement = Manager(self.proxy.cfg, self.proxy.store, self.proxy.tc, self.proxy.journal)
+            again = replacement.prepare(req, upstream=self.proxy.up)
+            self.assertEqual(warn.call_count, 1)
+        self.assertEqual(prepared.conv, again.conv)
+        self.assertLess(again.response_limit, 120000)
+        self.assertFalse(self.events('switch'))
+
+    def test_overfull_prompt_is_never_sent_without_segments(self):
+        self.proxy.cfg.mask_enabled = False
+        self.proxy.cfg.segments_enabled = False
+        status, _, _ = self.proxy.chat({'messages': [{'role': 'user', 'content': 'x' * 600000}],
+                                       'max_tokens': 120000})
+        self.assertEqual(status, 400)
+        self.assertFalse(self.eng.requests)