Skip to content

Commit 27625dd

Browse files
authored
fix(extensions): preserve filtered history during automatic compaction (#5103)
1 parent a2fdb94 commit 27625dd

15 files changed

Lines changed: 2612 additions & 121 deletions

‎src/agents/extensions/memory/async_sqlite_session.py‎

Lines changed: 108 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
import asyncio
44
import json
55
import sqlite3
6-
from collections.abc import AsyncIterator
6+
from collections.abc import AsyncIterator, Callable
77
from contextlib import asynccontextmanager
88
from pathlib import Path
99
from typing import Any, cast
@@ -12,6 +12,7 @@
1212

1313
from ...items import TResponseInputItem
1414
from ...memory import SessionABC
15+
from ...memory.session import _CompactionSnapshot
1516
from ...memory.session_settings import (
1617
SessionSettings,
1718
coerce_session_settings,
@@ -319,6 +320,111 @@ def _decode_rows(rows: list[Any]) -> list[TResponseInputItem]:
319320
await cursor.close()
320321
return _decode_rows(rows[::-1])
321322

323+
async def _insert_items(
324+
self, conn: aiosqlite.Connection, items: list[TResponseInputItem]
325+
) -> None:
326+
await conn.execute(
327+
f"""
328+
INSERT OR IGNORE INTO {self.sessions_table} (session_id) VALUES (?)
329+
""",
330+
(self.session_id,),
331+
)
332+
333+
message_data = [(self.session_id, json.dumps(item)) for item in items]
334+
await conn.executemany(
335+
f"""
336+
INSERT INTO {self.messages_table} (session_id, message_data) VALUES (?, ?)
337+
""",
338+
message_data,
339+
)
340+
341+
await conn.execute(
342+
f"""
343+
UPDATE {self.sessions_table}
344+
SET updated_at = CURRENT_TIMESTAMP
345+
WHERE session_id = ?
346+
""",
347+
(self.session_id,),
348+
)
349+
350+
async def _get_compaction_snapshot(
351+
self,
352+
limit: int,
353+
*,
354+
prune_prefix: Callable[[TResponseInputItem], bool] | None = None,
355+
) -> _CompactionSnapshot | None:
356+
if type(self) is not AsyncSQLiteSession:
357+
return None
358+
query = (
359+
f"SELECT id, message_data FROM {self.messages_table} "
360+
"WHERE session_id = ? ORDER BY id DESC LIMIT ?"
361+
)
362+
async with self._locked_connection() as conn:
363+
async with conn.execute(query, (self.session_id, limit)) as cursor:
364+
rows = list(await cursor.fetchall())[::-1]
365+
complete = len(rows) < limit
366+
if not complete:
367+
async with conn.execute(
368+
f"SELECT 1 FROM {self.messages_table} WHERE session_id = ? AND id < ? LIMIT 1",
369+
(self.session_id, rows[0][0]),
370+
) as cursor:
371+
complete = await cursor.fetchone() is None
372+
try:
373+
items = [json.loads(data) for _, data in rows]
374+
except (json.JSONDecodeError, TypeError):
375+
return None
376+
377+
async def replace_suffix(start: int, output: list[TResponseInputItem]) -> bool:
378+
expected = rows[start:]
379+
if not expected:
380+
return False
381+
382+
async def replace() -> bool:
383+
async with self._write_connection() as conn:
384+
await conn.execute("BEGIN IMMEDIATE")
385+
async with conn.execute(query, (self.session_id, len(expected))) as cursor:
386+
current = list(await cursor.fetchall())[::-1]
387+
if current != expected:
388+
await conn.rollback()
389+
return False
390+
if prune_prefix is not None:
391+
while True:
392+
async with conn.execute(
393+
f"SELECT id, message_data FROM {self.messages_table} "
394+
"WHERE session_id = ? AND id < ? ORDER BY id LIMIT ?",
395+
(self.session_id, expected[0][0], limit),
396+
) as cursor:
397+
prefix = list(await cursor.fetchall())
398+
expired_end = None
399+
for row_id, data in prefix:
400+
try:
401+
item = json.loads(data)
402+
except (json.JSONDecodeError, TypeError):
403+
break
404+
if not prune_prefix(item):
405+
break
406+
expired_end = row_id
407+
if expired_end is None:
408+
break
409+
await conn.execute(
410+
f"DELETE FROM {self.messages_table} "
411+
"WHERE session_id = ? AND id <= ?",
412+
(self.session_id, expired_end),
413+
)
414+
if expired_end != prefix[-1][0] or len(prefix) < limit:
415+
break
416+
await conn.execute(
417+
f"DELETE FROM {self.messages_table} WHERE session_id = ? AND id >= ?",
418+
(self.session_id, expected[0][0]),
419+
)
420+
await self._insert_items(conn, output)
421+
await conn.commit()
422+
return True
423+
424+
return await _await_mutation(replace())
425+
426+
return _CompactionSnapshot(items, complete, replace_suffix)
427+
322428
async def add_items(self, items: list[TResponseInputItem]) -> None:
323429
"""Add new items to the conversation history.
324430
@@ -330,29 +436,7 @@ async def add_items(self, items: list[TResponseInputItem]) -> None:
330436
return
331437

332438
async with self._write_connection() as conn:
333-
await conn.execute(
334-
f"""
335-
INSERT OR IGNORE INTO {self.sessions_table} (session_id) VALUES (?)
336-
""",
337-
(self.session_id,),
338-
)
339-
340-
message_data = [(self.session_id, json.dumps(item)) for item in items]
341-
await conn.executemany(
342-
f"""
343-
INSERT INTO {self.messages_table} (session_id, message_data) VALUES (?, ?)
344-
""",
345-
message_data,
346-
)
347-
348-
await conn.execute(
349-
f"""
350-
UPDATE {self.sessions_table}
351-
SET updated_at = CURRENT_TIMESTAMP
352-
WHERE session_id = ?
353-
""",
354-
(self.session_id,),
355-
)
439+
await self._insert_items(conn, items)
356440

357441
await _await_mutation(conn.commit())
358442

‎src/agents/extensions/memory/encrypt_session.py‎

Lines changed: 89 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@
2929

3030
import base64
3131
import json
32+
import time
3233
from typing import Any, Literal, TypeGuard, cast
3334

3435
from cryptography.fernet import Fernet, InvalidToken
@@ -40,8 +41,10 @@
4041
from ...memory.openai_responses_compaction_session import OpenAIResponsesCompactionSession
4142
from ...memory.session import (
4243
OpenAIResponsesCompactionArgs,
44+
Session,
4345
SessionABC,
4446
_call_session_method,
47+
_CompactionSnapshot,
4548
_get_session_wrapper,
4649
)
4750
from ...memory.session_settings import SessionSettings, resolve_session_limit
@@ -116,6 +119,8 @@ class EncryptedSession(SessionABC):
116119
the cumulative number of items retrieved and unwrapped per ``get_items`` call;
117120
overlapping backfill windows count again. This does not bound item byte size,
118121
backend-internal work, elapsed time, or ``pop_item`` work.
122+
Successful automatic compaction on native SQLite and SQLAlchemy stores reclaims a
123+
contiguous prefix of authenticated expired envelopes in bounded batches.
119124
120125
Note: Expired tokens are rejected based on the system clock of the application server.
121126
To avoid valid tokens being rejected due to clock drift, ensure all servers in
@@ -159,6 +164,9 @@ def __init__(
159164
self.cipher = _derive_session_fernet_key(master, session_id)
160165
self._kid = "hkdf-v1"
161166
self._ver = 1
167+
# One-use read budget for envelopes omitted by the latest history read.
168+
# This is not evidence of completeness or permission to replace history.
169+
self._compaction_read_overhead = 0
162170

163171
def __getattr__(self, name: str) -> Any:
164172
# Expose compaction only when the underlying session actually supports it.
@@ -179,10 +187,9 @@ async def _run_compaction(
179187
await session._run_compaction(
180188
args,
181189
wrapper=wrapper,
182-
read_items=lambda: _call_session_method(
183-
self.get_items, wrapper=_get_session_wrapper(self, wrapper)
184-
),
190+
read_items=lambda limit: self._read_compaction_items(limit, wrapper=wrapper),
185191
prepare_items=self._encrypt_items,
192+
read_snapshot=self._get_compaction_snapshot,
186193
)
187194

188195
async def _defer_encrypted_compaction(
@@ -196,10 +203,83 @@ async def _defer_encrypted_compaction(
196203
await session._defer_compaction(
197204
response_id,
198205
store,
199-
read_items=lambda: _call_session_method(
206+
read_items=lambda limit: self._read_compaction_items(limit, wrapper=wrapper),
207+
)
208+
209+
async def _get_compaction_snapshot(self, limit: int) -> _CompactionSnapshot | None:
210+
backend: Session = self.underlying_session
211+
if isinstance(backend, OpenAIResponsesCompactionSession):
212+
backend = backend.underlying_session
213+
reader = getattr(backend, "_get_compaction_snapshot", None)
214+
if reader is None:
215+
return None
216+
# Authenticate timestamps before authorizing deletion; InvalidToken alone
217+
# can also mean a wrong key, corruption or a future timestamp.
218+
expired_before = int(time.time()) - self.ttl
219+
cipher = self.cipher
220+
221+
def is_expired(item: TResponseInputItem) -> bool:
222+
if not _is_encrypted_envelope(item):
223+
return False
224+
try:
225+
return cipher.extract_timestamp(item["payload"]) < expired_before
226+
except (InvalidToken, TypeError):
227+
return False
228+
229+
raw: _CompactionSnapshot | None = await reader(limit, prune_prefix=is_expired)
230+
if raw is None:
231+
return None
232+
items: list[TResponseInputItem] = []
233+
positions: list[int] = []
234+
retained_boundary = 0
235+
for index, encrypted_item in enumerate(raw.items):
236+
item = self._unwrap(encrypted_item)
237+
if item is not None:
238+
items.append(item)
239+
positions.append(index)
240+
elif not is_expired(encrypted_item):
241+
# An unreadable envelope is not necessarily expired. Keep it and
242+
# everything before it outside the eligible replacement suffix.
243+
retained_boundary = index + 1
244+
items.clear()
245+
positions.clear()
246+
247+
async def replace_suffix(start: int, output: list[TResponseInputItem]) -> bool:
248+
# Observed expired rows may be part of the selected raw suffix.
249+
# The transaction separately reclaims the authenticated expired prefix.
250+
raw_start = retained_boundary if start == 0 else positions[start]
251+
return await raw.replace_suffix(raw_start, self._encrypt_items(output))
252+
253+
return _CompactionSnapshot(items, raw.complete and retained_boundary == 0, replace_suffix)
254+
255+
async def _read_compaction_items(
256+
self, limit: int | None, *, wrapper: RunContextWrapper[Any] | None = None
257+
) -> tuple[list[TResponseInputItem], bool]:
258+
if limit is None:
259+
# A default-limited policy read must not discard overhead already
260+
# observed by a larger model-history read.
261+
overhead = self._compaction_read_overhead
262+
items = await _call_session_method(
200263
self.get_items, wrapper=_get_session_wrapper(self, wrapper)
264+
)
265+
self._compaction_read_overhead = max(overhead, self._compaction_read_overhead)
266+
return items, False
267+
# Reuse only overhead already observed during ordinary history retrieval.
268+
# Consume it before I/O; current raw completeness and plaintext visibility
269+
# still decide whether compaction can replace the stored history.
270+
raw_limit = limit + self._compaction_read_overhead
271+
self._compaction_read_overhead = 0
272+
items = cast(
273+
list[TResponseInputItem],
274+
await _call_session_method(
275+
self.underlying_session.get_items,
276+
raw_limit,
277+
wrapper=_get_session_wrapper(self.underlying_session, wrapper),
201278
),
202279
)
280+
if len(items) >= raw_limit:
281+
return [], False
282+
return self._unwrap_valid_items(items), True
203283

204284
@property
205285
def session_settings(self) -> SessionSettings | None:
@@ -251,6 +331,7 @@ async def get_items(
251331
*,
252332
wrapper: RunContextWrapper[Any] | None = None,
253333
) -> list[TResponseInputItem]:
334+
self._compaction_read_overhead = 0
254335
wrapper = _get_session_wrapper(self.underlying_session, wrapper)
255336
effective_limit = resolve_session_limit(limit, self.session_settings)
256337
remaining = self.max_scan_items
@@ -272,6 +353,7 @@ async def get_items(
272353
),
273354
)
274355
valid_items = self._unwrap_valid_items(encrypted_items)
356+
self._compaction_read_overhead = len(encrypted_items) - len(valid_items)
275357
if (
276358
positive_limit
277359
and effective_limit is not None
@@ -300,7 +382,9 @@ async def get_items(
300382
wrapper=wrapper,
301383
),
302384
)
303-
return self._unwrap_valid_items(encrypted_items)
385+
valid_items = self._unwrap_valid_items(encrypted_items)
386+
self._compaction_read_overhead = len(encrypted_items) - len(valid_items)
387+
return valid_items
304388

305389
def _encrypt_items(self, items: list[TResponseInputItem]) -> list[TResponseInputItem]:
306390
return cast(list[TResponseInputItem], [self._wrap(item) for item in items])

0 commit comments

Comments
 (0)