agentforge-chat 0.2.1__py3-none-any.whl

agentforge_chat/sqlite.py

@@ -0,0 +1,276 @@
+"""`SqliteChatHistory` — `ChatHistoryStore` over SQLite via aiosqlite.
+
+Two tables: ``chat_turns`` (one row per turn) and ``chat_sessions``
+(one row per session). Indexed on ``(session_id, created_at)`` so
+``load()`` is sub-linear w.r.t. total turn count.
+
+Schema is created via ``init_schema()`` / ``from_path()``.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from datetime import datetime
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+import aiosqlite
+from agentforge_core.contracts.chat import ChatHistoryStore
+from agentforge_core.production.exceptions import ModuleError
+from agentforge_core.values.chat import ChatTurn, SessionInfo
+from agentforge_core.values.messages import ToolCall
+
+_SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS chat_sessions (
+    id              TEXT PRIMARY KEY,
+    owner           TEXT,
+    created_at      TEXT NOT NULL,
+    last_active_at  TEXT NOT NULL,
+    metadata        TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_owner
+    ON chat_sessions(owner);
+CREATE INDEX IF NOT EXISTS idx_sessions_last_active
+    ON chat_sessions(last_active_at);
+CREATE TABLE IF NOT EXISTS chat_turns (
+    id              TEXT PRIMARY KEY,
+    session_id      TEXT NOT NULL,
+    role            TEXT NOT NULL,
+    content         TEXT NOT NULL,
+    timestamp       TEXT NOT NULL,
+    run_id          TEXT,
+    tool_calls      TEXT NOT NULL,
+    tool_call_id    TEXT,
+    tokens_in       INTEGER NOT NULL,
+    tokens_out      INTEGER NOT NULL,
+    cost_usd        REAL NOT NULL,
+    metadata        TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_turns_session_ts
+    ON chat_turns(session_id, timestamp);
+"""
+
+
+class SqliteChatHistory(ChatHistoryStore):
+    """`ChatHistoryStore` backed by a single SQLite file."""
+
+    def __init__(self, *, connection: aiosqlite.Connection) -> None:
+        self._db = connection
+
+    @classmethod
+    async def from_path(cls, path: str | Path) -> SqliteChatHistory:
+        """Open or create a SQLite database at ``path``.
+
+        ``":memory:"`` is allowed for tests; on disk the parent
+        directory must already exist.
+        """
+        connection = await aiosqlite.connect(str(path))
+        connection.row_factory = aiosqlite.Row
+        await connection.executescript(_SCHEMA_SQL)
+        await connection.commit()
+        return cls(connection=connection)
+
+    async def __aenter__(self) -> SqliteChatHistory:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        await self._db.close()
+
+    async def append(self, turn: ChatTurn) -> None:
+        ts_iso = turn.timestamp.isoformat()
+        await self._db.execute(
+            """INSERT OR REPLACE INTO chat_turns
+               (id, session_id, role, content, timestamp, run_id,
+                tool_calls, tool_call_id, tokens_in, tokens_out,
+                cost_usd, metadata)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                turn.id,
+                turn.session_id,
+                turn.role,
+                turn.content,
+                ts_iso,
+                turn.run_id,
+                json.dumps([tc.model_dump(mode="json") for tc in turn.tool_calls]),
+                turn.tool_call_id,
+                turn.tokens_in,
+                turn.tokens_out,
+                turn.cost_usd,
+                json.dumps(turn.metadata),
+            ),
+        )
+        await self._upsert_session(turn.session_id, ts_iso)
+        await self._db.commit()
+
+    async def _upsert_session(self, session_id: str, now_iso: str) -> None:
+        await self._db.execute(
+            """INSERT INTO chat_sessions
+               (id, owner, created_at, last_active_at, metadata)
+               VALUES (?, NULL, ?, ?, ?)
+               ON CONFLICT(id) DO UPDATE SET last_active_at=excluded.last_active_at""",
+            (session_id, now_iso, now_iso, "{}"),
+        )
+
+    async def load(
+        self,
+        session_id: str,
+        *,
+        limit: int | None = None,
+        before: datetime | None = None,
+        after: datetime | None = None,
+        roles: list[str] | None = None,
+    ) -> list[ChatTurn]:
+        where = ["session_id = ?"]
+        params: list[Any] = [session_id]
+        if before is not None:
+            where.append("timestamp < ?")
+            params.append(before.isoformat())
+        if after is not None:
+            where.append("timestamp > ?")
+            params.append(after.isoformat())
+        if roles is not None:
+            placeholders = ", ".join("?" * len(roles))
+            where.append(f"role IN ({placeholders})")  # nosec B608 — `?` placeholders only
+            params.extend(roles)
+        sql = (
+            "SELECT * FROM chat_turns WHERE "  # noqa: S608  # nosec B608
+            + " AND ".join(where)
+            + " ORDER BY timestamp"
+        )
+        if limit is not None:
+            sql += " LIMIT ?"
+            params.append(limit)
+        async with self._db.execute(sql, params) as cur:
+            rows = await cur.fetchall()
+        return [_row_to_turn(row) for row in rows]
+
+    async def count(self, session_id: str) -> int:
+        async with self._db.execute(
+            "SELECT COUNT(*) FROM chat_turns WHERE session_id = ?",
+            (session_id,),
+        ) as cur:
+            row = await cur.fetchone()
+        return int(row[0]) if row else 0
+
+    async def delete_session(self, session_id: str) -> int:
+        cur = await self._db.execute(
+            "DELETE FROM chat_turns WHERE session_id = ?",
+            (session_id,),
+        )
+        removed = cur.rowcount or 0
+        await self._db.execute(
+            "DELETE FROM chat_sessions WHERE id = ?",
+            (session_id,),
+        )
+        await self._db.commit()
+        return removed
+
+    async def list_sessions(
+        self,
+        *,
+        owner: str | None = None,
+        limit: int = 100,
+        before: datetime | None = None,
+    ) -> list[SessionInfo]:
+        where: list[str] = []
+        params: list[Any] = []
+        if owner is not None:
+            where.append("owner = ?")
+            params.append(owner)
+        if before is not None:
+            where.append("last_active_at < ?")
+            params.append(before.isoformat())
+        sql = "SELECT * FROM chat_sessions"
+        if where:
+            sql += " WHERE " + " AND ".join(where)
+        sql += " ORDER BY last_active_at DESC LIMIT ?"  # nosec B608
+        params.append(limit)
+        async with self._db.execute(sql, params) as cur:
+            rows = await cur.fetchall()
+        return [await self._row_to_info(row) for row in rows]
+
+    async def update_session_metadata(self, session_id: str, metadata: Mapping[str, Any]) -> None:
+        async with self._db.execute(
+            "SELECT metadata, owner FROM chat_sessions WHERE id = ?",
+            (session_id,),
+        ) as cur:
+            row = await cur.fetchone()
+        if row is None:
+            raise ModuleError(f"Cannot update metadata for unknown session {session_id!r}")
+        existing = json.loads(row["metadata"])
+        existing.update(dict(metadata))
+        owner = metadata.get("owner", row["owner"])
+        await self._db.execute(
+            "UPDATE chat_sessions SET metadata = ?, owner = ? WHERE id = ?",
+            (json.dumps(existing), owner, session_id),
+        )
+        await self._db.commit()
+
+    async def expire_before(self, cutoff: datetime) -> int:
+        cutoff_iso = cutoff.isoformat()
+        await self._db.execute(
+            """DELETE FROM chat_turns WHERE session_id IN (
+                 SELECT id FROM chat_sessions WHERE last_active_at < ?
+               )""",
+            (cutoff_iso,),
+        )
+        cur = await self._db.execute(
+            "DELETE FROM chat_sessions WHERE last_active_at < ?",
+            (cutoff_iso,),
+        )
+        removed = cur.rowcount or 0
+        await self._db.commit()
+        return removed
+
+    def capabilities(self) -> set[str]:
+        return {"ttl"}
+
+    async def _row_to_info(self, row: Any) -> SessionInfo:
+        async with self._db.execute(
+            "SELECT COUNT(*), COALESCE(SUM(cost_usd), 0.0) FROM chat_turns WHERE session_id = ?",
+            (row["id"],),
+        ) as cur:
+            agg = await cur.fetchone()
+        count = int(agg[0]) if agg else 0
+        cost = float(agg[1]) if agg else 0.0
+        return SessionInfo(
+            id=row["id"],
+            owner=row["owner"],
+            created_at=datetime.fromisoformat(row["created_at"]),
+            last_active_at=datetime.fromisoformat(row["last_active_at"]),
+            turn_count=count,
+            total_cost_usd=cost,
+            metadata=json.loads(row["metadata"]),
+        )
+
+
+def _row_to_turn(row: Any) -> ChatTurn:
+    raw_calls = json.loads(row["tool_calls"])
+    tool_calls = tuple(ToolCall.model_validate(tc) for tc in raw_calls)
+    return ChatTurn(
+        id=row["id"],
+        session_id=row["session_id"],
+        role=row["role"],
+        content=row["content"],
+        timestamp=datetime.fromisoformat(row["timestamp"]),
+        run_id=row["run_id"],
+        tool_calls=tool_calls,
+        tool_call_id=row["tool_call_id"],
+        tokens_in=int(row["tokens_in"]),
+        tokens_out=int(row["tokens_out"]),
+        cost_usd=float(row["cost_usd"]),
+        metadata=json.loads(row["metadata"]),
+    )
+
+
+__all__ = ["SqliteChatHistory"]

agentforge_chat/tokenisers.py

@@ -0,0 +1,91 @@
+"""Provider-aware tokenisers for `TokenBudget` (feat-020 v0.2).
+
+The default `TokenBudget` ships a 4-chars-per-token heuristic
+that works for English-ish prose but drifts widely on code +
+non-ASCII content. For accurate budget enforcement, supply a
+`Tokeniser`: any callable that maps a string to a token count.
+
+Two built-ins:
+
+- :func:`tiktoken_tokeniser` — counts via the
+  `tiktoken` library used by OpenAI-compatible models.
+- :func:`anthropic_tokeniser` — counts via the Anthropic
+  SDK's `count_tokens` API.
+
+Both lazy-import their backing SDKs and raise :class:`ModuleError`
+with pip remediation when the SDK isn't installed. Users
+provide their own callable when they want a different
+tokeniser.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from functools import lru_cache
+from typing import Any, cast
+
+from agentforge_core.production.exceptions import ModuleError
+
+Tokeniser = Callable[[str], int]
+"""Map an input string to a non-negative integer token count."""
+
+
+@lru_cache(maxsize=8)
+def _load_tiktoken_encoding(model: str) -> Any:  # pragma: no cover — exercised via build
+    try:
+        import tiktoken  # noqa: PLC0415
+    except ImportError as exc:
+        msg = (
+            "tiktoken is not installed. Install via "
+            "`pip install tiktoken` to use tiktoken_tokeniser."
+        )
+        raise ModuleError(msg) from exc
+    try:
+        return tiktoken.encoding_for_model(model)
+    except KeyError:
+        return tiktoken.get_encoding("cl100k_base")
+
+
+def tiktoken_tokeniser(model: str = "gpt-4o-mini") -> Tokeniser:
+    """Build a tiktoken-backed `Tokeniser` for ``model``.
+
+    Falls back to the ``cl100k_base`` encoding when the model
+    name isn't in tiktoken's registry.
+    """
+    enc = _load_tiktoken_encoding(model)
+
+    def _count(text: str) -> int:
+        return len(enc.encode(text))
+
+    return _count
+
+
+def anthropic_tokeniser() -> Tokeniser:  # pragma: no cover — exercised via build
+    """Build an Anthropic-SDK-backed `Tokeniser`.
+
+    Uses the synchronous `count_tokens(text)` method on a
+    process-wide Anthropic client. Suitable for offline token
+    counting where no API key is needed.
+    """
+    try:
+        import anthropic  # noqa: PLC0415
+    except ImportError as exc:
+        msg = (
+            "anthropic SDK is not installed. Install via "
+            "`pip install anthropic` to use anthropic_tokeniser."
+        )
+        raise ModuleError(msg) from exc
+
+    client = anthropic.Anthropic()
+
+    def _count(text: str) -> int:
+        return int(cast("Any", client).count_tokens(text))
+
+    return _count
+
+
+__all__ = [
+    "Tokeniser",
+    "anthropic_tokeniser",
+    "tiktoken_tokeniser",
+]

agentforge_chat/truncation.py

@@ -0,0 +1,206 @@
+"""Truncation strategies (feat-020).
+
+Four built-ins ship in v0.2:
+
+- `SlidingWindow(max_turns=N)` — keep the last N turns.
+- `TokenBudget(max_tokens=N)` — keep as many recent turns as fit
+  under N tokens (approximate, using a 4-chars-per-token heuristic
+  in v0.2; provider-aware tokenisation is a follow-up).
+- `SummariseOldest(threshold_turns=N, summariser=cb)` — keep the
+  last N turns verbatim; everything older condenses to a single
+  ``system`` turn via the supplied summariser callback.
+- `Hybrid(*strategies)` — pipe input through each strategy in
+  order; later strategies see the previous strategy's output.
+
+Each respects the conformance invariants documented in
+`agentforge_core.contracts.chat.HistoryTruncationStrategy`:
+order-preserving + tool-call/tool-result pair atomicity.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Mapping
+from typing import Any
+
+from agentforge_core.contracts.chat import HistoryTruncationStrategy
+from agentforge_core.values.chat import ChatTurn
+
+from agentforge_chat.tokenisers import Tokeniser
+
+SummariserCallback = Callable[[list[ChatTurn]], Awaitable[str]]
+"""Async callback that turns a batch of turns into a single
+summary string. The default implementation in `SummariseOldest`
+concatenates contents — production users supply an LLM-backed
+summariser."""
+
+_CHARS_PER_TOKEN = 4
+"""Approximate chars-per-token heuristic for `TokenBudget`."""
+
+
+def _approx_tokens(turn: ChatTurn) -> int:
+    return max(1, len(turn.content) // _CHARS_PER_TOKEN)
+
+
+def _keep_pair_atomic(turns: list[ChatTurn]) -> list[ChatTurn]:
+    """Drop a leading orphan tool turn that lost its act partner.
+
+    The truncation contract says tool-call/tool-result pairs must
+    not be split. We enforce by dropping any tool turn whose
+    preceding assistant turn isn't in the selection.
+    """
+    if not turns:
+        return turns
+    out: list[ChatTurn] = []
+    last_role: str | None = None
+    for t in turns:
+        if t.role == "tool" and last_role != "assistant":
+            continue
+        out.append(t)
+        last_role = t.role
+    return out
+
+
+class SlidingWindow(HistoryTruncationStrategy):
+    """Keep the most recent ``max_turns`` turns."""
+
+    def __init__(self, max_turns: int = 50) -> None:
+        if max_turns < 1:
+            raise ValueError(f"max_turns must be >= 1, got {max_turns}")
+        self.max_turns = max_turns
+
+    async def select(
+        self,
+        all_turns: list[ChatTurn],
+        next_user_message: str,
+        context: Mapping[str, Any],
+    ) -> list[ChatTurn]:
+        del next_user_message, context
+        kept = all_turns[-self.max_turns :]
+        return _keep_pair_atomic(kept)
+
+
+class TokenBudget(HistoryTruncationStrategy):
+    """Keep recent turns until ``max_tokens`` is exhausted.
+
+    Token counting defaults to the 4-chars-per-token heuristic.
+    Pass a ``tokeniser`` callable to use a provider-aware
+    encoder — e.g. :func:`agentforge_chat.tokenisers.tiktoken_tokeniser`
+    for OpenAI-compatible models or
+    :func:`agentforge_chat.tokenisers.anthropic_tokeniser` for
+    Anthropic. The callable maps a string to its token count.
+    """
+
+    def __init__(
+        self,
+        max_tokens: int = 64_000,
+        *,
+        tokeniser: Tokeniser | None = None,
+    ) -> None:
+        if max_tokens < 1:
+            raise ValueError(f"max_tokens must be >= 1, got {max_tokens}")
+        self.max_tokens = max_tokens
+        self._tokeniser = tokeniser
+
+    def _tokens_for_text(self, text: str) -> int:
+        if self._tokeniser is None:
+            return max(1, len(text) // _CHARS_PER_TOKEN)
+        return max(0, int(self._tokeniser(text)))
+
+    def _tokens_for_turn(self, turn: ChatTurn) -> int:
+        if self._tokeniser is None:
+            return _approx_tokens(turn)
+        return max(1, int(self._tokeniser(turn.content)))
+
+    async def select(
+        self,
+        all_turns: list[ChatTurn],
+        next_user_message: str,
+        context: Mapping[str, Any],
+    ) -> list[ChatTurn]:
+        del context
+        # Reserve budget for the next user message itself.
+        reserved = self._tokens_for_text(next_user_message)
+        remaining = self.max_tokens - reserved
+        chosen: list[ChatTurn] = []
+        for turn in reversed(all_turns):
+            cost = self._tokens_for_turn(turn)
+            if cost > remaining:
+                break
+            chosen.append(turn)
+            remaining -= cost
+        chosen.reverse()
+        return _keep_pair_atomic(chosen)
+
+
+class SummariseOldest(HistoryTruncationStrategy):
+    """Keep the last ``threshold_turns``; condense older turns
+    into a single ``system`` summary turn."""
+
+    def __init__(
+        self,
+        *,
+        threshold_turns: int = 30,
+        summariser: SummariserCallback | None = None,
+    ) -> None:
+        if threshold_turns < 1:
+            raise ValueError(f"threshold_turns must be >= 1, got {threshold_turns}")
+        self.threshold_turns = threshold_turns
+        self.summariser: SummariserCallback = (
+            summariser if summariser is not None else _default_summariser
+        )
+
+    async def select(
+        self,
+        all_turns: list[ChatTurn],
+        next_user_message: str,
+        context: Mapping[str, Any],
+    ) -> list[ChatTurn]:
+        del next_user_message, context
+        if len(all_turns) <= self.threshold_turns:
+            return _keep_pair_atomic(list(all_turns))
+        older = all_turns[: -self.threshold_turns]
+        recent = all_turns[-self.threshold_turns :]
+        summary_text = await self.summariser(older)
+        summary = ChatTurn(
+            id=f"summary-{older[0].id}-{older[-1].id}",
+            session_id=older[0].session_id,
+            role="system",
+            content=f"[Summary of {len(older)} older turns] {summary_text}",
+            timestamp=older[0].timestamp,
+            metadata={"agentforge_chat.summary": True},
+        )
+        return _keep_pair_atomic([summary, *recent])
+
+
+class Hybrid(HistoryTruncationStrategy):
+    """Compose strategies in series: each runs against the
+    previous strategy's output."""
+
+    def __init__(self, *strategies: HistoryTruncationStrategy) -> None:
+        if not strategies:
+            raise ValueError("Hybrid requires at least one strategy")
+        self.strategies = strategies
+
+    async def select(
+        self,
+        all_turns: list[ChatTurn],
+        next_user_message: str,
+        context: Mapping[str, Any],
+    ) -> list[ChatTurn]:
+        current = list(all_turns)
+        for s in self.strategies:
+            current = await s.select(current, next_user_message, context)
+        return current
+
+
+async def _default_summariser(turns: list[ChatTurn]) -> str:
+    pieces = [f"{t.role}: {t.content}" for t in turns]
+    return " | ".join(pieces)[:2000]
+
+
+__all__ = [
+    "Hybrid",
+    "SlidingWindow",
+    "SummariseOldest",
+    "TokenBudget",
+]

agentforge_chat-0.2.1.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: agentforge-chat
+Version: 0.2.1
+Summary: Chat-agent runtime (ChatSession + history drivers + truncation) for AgentForge
+Project-URL: Homepage, https://github.com/Scaffoldic/agentforge-py
+Project-URL: Repository, https://github.com/Scaffoldic/agentforge-py
+Project-URL: Documentation, https://github.com/Scaffoldic/agentforge-py
+Project-URL: Changelog, https://github.com/Scaffoldic/agentforge-py/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Scaffoldic/agentforge-py/issues
+Author: The AgentForge Authors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agent,ai,chat,chatbot,conversation
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: agentforge-core~=0.2.1
+Requires-Dist: agentforge-py~=0.2.1
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite>=0.20; extra == 'sqlite'
+Description-Content-Type: text/markdown
+
+# agentforge-chat
+
+Chat-agent runtime for AgentForge: `ChatSession`,
+`InMemoryChatHistory` / `SqliteChatHistory` drivers, and four
+truncation strategies (sliding-window, token-budget,
+summarise-oldest, hybrid).
+
+See [`docs/features/feat-020-chat-agents.md`](https://github.com/Scaffoldic/agentforge-py/blob/main/docs/features/feat-020-chat-agents.md)
+for the design and runbook.
+
+## Install
+
+```bash
+pip install agentforge-chat
+# or, with the SQLite driver pre-pulled:
+pip install "agentforge-chat[sqlite]"
+```
+
+## Three-line chat from a one-shot agent
+
+```python
+from agentforge import Agent
+from agentforge_chat import ChatSession, SqliteChatHistory
+
+agent = Agent(model="anthropic:claude-sonnet-4-6", strategy="react")
+session = ChatSession(
+    agent=agent,
+    history_store=await SqliteChatHistory.from_path("./chat.db"),
+)
+print((await session.send("Hi")).content)
+print((await session.send("What did I just say?")).content)
+```

agentforge_chat-0.2.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+agentforge_chat/__init__.py,sha256=av4ETJyvjnKJ1uCub6QlpgA82Mu0kEpA03yb3vrmzbA,1050
+agentforge_chat/_idempotency.py,sha256=1ekiRDJC6SxVYklxsKCfW0A80BawNMzD6FHkcpHZS5Q,1232
+agentforge_chat/_locks.py,sha256=stV_5isaEmyk4T1CW5Bs2ExiSZ7F2ayoltJN_PFIwg4,3411
+agentforge_chat/_segment.py,sha256=5EPSLgukC5sroU5lhIr0TK4Tjh52VzU1eMlEg7d4lAg,1339
+agentforge_chat/_window.py,sha256=HOT6vmMkX7Xxm1UPPyoTtBjy_Esm8YZNEsUqV_pjGLc,2944
+agentforge_chat/build.py,sha256=9UXGAWhO8elY98k-_AOmnwc4FxtHBsXQJaPMPnniaL4,4039
+agentforge_chat/history.py,sha256=Uv7rzlOrSHMegXKDJgxTIPoCSgNzguMYVmidSO56DqQ,4510
+agentforge_chat/manifest.yaml,sha256=i9rASO_QPu_74ZxRweKmeiIG9gu8pXR_A_s6VgB0QTc,1023
+agentforge_chat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentforge_chat/session.py,sha256=7KA8hZ1efeWUlraZ33WVgrFkObwXnCCcIX93oD6Trhc,19448
+agentforge_chat/sqlite.py,sha256=-p2w8MAiTqLLbCSIiRypNvVwreONCWyhtfKsX-6owks,9591
+agentforge_chat/tokenisers.py,sha256=JgU8ELf6rjuexC4Ha1LLQZyJBT8LZFyfCUs7Y-3WX9Y,2704
+agentforge_chat/truncation.py,sha256=7FX2Mu4RiJ5KmTV4aPOOFeqXyz5TmXmJ0OdHR8jg7aM,6922
+agentforge_chat-0.2.1.dist-info/METADATA,sha256=W4KH6lEmzqpK12K9sYAM6BuhD1psJoeaaADQA4Sg8Ec,2150
+agentforge_chat-0.2.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentforge_chat-0.2.1.dist-info/entry_points.txt,sha256=hZaTWW0rtnD_FSFT21Cou6kkmcYa7jSSwyr1U2fzGmA,376
+agentforge_chat-0.2.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+agentforge_chat-0.2.1.dist-info/RECORD,,

agentforge_chat-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentforge_chat-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[agentforge.chat.history]
+memory = agentforge_chat.history:InMemoryChatHistory
+sqlite = agentforge_chat.sqlite:SqliteChatHistory
+
+[agentforge.chat.truncation]
+hybrid = agentforge_chat.truncation:Hybrid
+sliding_window = agentforge_chat.truncation:SlidingWindow
+summarise_oldest = agentforge_chat.truncation:SummariseOldest
+token_budget = agentforge_chat.truncation:TokenBudget