agentforge-chat 0.2.2__tar.gz → 0.2.4__tar.gz

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentforge-chat
-Version: 0.2.2
+Version: 0.2.4
 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
@@ -19,10 +19,9 @@ 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.2
-Requires-Dist: agentforge-py~=0.2.2
-Provides-Extra: sqlite
-Requires-Dist: aiosqlite>=0.20; extra == 'sqlite'
+Requires-Dist: agentforge-core~=0.2.4
+Requires-Dist: agentforge-py~=0.2.4
+Requires-Dist: aiosqlite>=0.20
 Description-Content-Type: text/markdown
 
 # agentforge-chat
@@ -39,10 +38,11 @@ for the design and runbook.
 
 ```bash
 pip install agentforge-chat
-# or, with the SQLite driver pre-pulled:
-pip install "agentforge-chat[sqlite]"
 ```
 
+The SQLite history driver (`SqliteChatHistory`) works out of the box —
+`aiosqlite` ships as a hard dependency.
+
 ## Three-line chat from a one-shot agent
 
 ```python

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/README.md

@@ -12,10 +12,11 @@ for the design and runbook.
 
 ```bash
 pip install agentforge-chat
-# or, with the SQLite driver pre-pulled:
-pip install "agentforge-chat[sqlite]"
 ```
 
+The SQLite history driver (`SqliteChatHistory`) works out of the box —
+`aiosqlite` ships as a hard dependency.
+
 ## Three-line chat from a one-shot agent
 
 ```python

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/pyproject.toml

@@ -9,7 +9,7 @@
 
 [project]
 name = "agentforge-chat"
-version = "0.2.2"
+version = "0.2.4"
 description = "Chat-agent runtime (ChatSession + history drivers + truncation) for AgentForge"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -30,13 +30,16 @@ classifiers = [
 ]
 
 dependencies = [
-    "agentforge-core ~= 0.2.2",
-    "agentforge-py ~= 0.2.2",
+    "agentforge-core ~= 0.2.4",
+    "agentforge-py ~= 0.2.4",
+    # aiosqlite is a hard dependency, not an optional extra: the package
+    # eagerly imports SqliteChatHistory (agentforge_chat/__init__.py ->
+    # sqlite.py -> `import aiosqlite`), so `import agentforge_chat` fails
+    # without it. Mirrors the sibling agentforge-memory-sqlite, which also
+    # hard-deps aiosqlite. (bug-015 audit.)
+    "aiosqlite>=0.20",
 ]
 
-[project.optional-dependencies]
-sqlite = ["aiosqlite>=0.20"]
-
 [project.urls]
 Homepage = "https://github.com/Scaffoldic/agentforge-py"
 Repository = "https://github.com/Scaffoldic/agentforge-py"

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/src/agentforge_chat/build.py

@@ -48,6 +48,7 @@ async def build_chat_session_from_config(
     per_session = None
     idem_window = 60.0
     safety_mode: SafetyMode = "buffer-then-stream"
+    persist_steps = True
     if chat_cfg is not None:
         if chat_cfg.history is not None:
             history = await _build_history(chat_cfg.history.driver, chat_cfg.history.config)
@@ -57,6 +58,7 @@ async def build_chat_session_from_config(
         per_session = chat_cfg.session.per_session_budget_usd
         idem_window = chat_cfg.session.idempotency_window_s
         safety_mode = chat_cfg.session.safety_mode
+        persist_steps = chat_cfg.session.persist_steps
     return ChatSession(
         agent=agent,
         session_id=session_id,
@@ -68,6 +70,7 @@ async def build_chat_session_from_config(
         per_session_budget_usd=per_session,
         idempotency_window_s=idem_window,
         safety_mode=safety_mode,
+        persist_steps=persist_steps,
     )
 
 

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/src/agentforge_chat/history.py

@@ -77,7 +77,10 @@ class InMemoryChatHistory(ChatHistoryStore):
         before: datetime | None = None,
     ) -> list[SessionInfo]:
         async with self._lock:
-            out = [self._build_info(sid) for sid in self._turns]
+            # Include sessions that exist only via metadata (created before
+            # their first turn — bug-018), not just sessions with turns.
+            sids = set(self._turns) | set(self._meta)
+            out = [self._build_info(sid) for sid in sids]
         if owner is not None:
             out = [s for s in out if s.owner == owner]
         if before is not None:
@@ -92,6 +95,11 @@ class InMemoryChatHistory(ChatHistoryStore):
                 bag[k] = v
             if "owner" in metadata:
                 self._owners[session_id] = metadata["owner"]
+            # Register timestamps so a metadata-only session (created before
+            # its first turn — bug-018) carries sane created/last_active.
+            now = datetime.now(UTC)
+            self._created_at.setdefault(session_id, now)
+            self._last_active.setdefault(session_id, now)
 
     async def expire_before(self, cutoff: datetime) -> int:
         async with self._lock:

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/src/agentforge_chat/manifest.yaml

@@ -11,7 +11,7 @@ distribution:
 config_block:
   modules.chat:
     history:
-      driver: memory   # memory | sqlite (sqlite needs `agentforge-chat[sqlite]`)
+      driver: memory   # memory | sqlite (both ship with agentforge-chat)
       config: {}
     truncation:
       strategy: sliding_window

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/src/agentforge_chat/session.py

@@ -23,6 +23,7 @@ streaming work documented in feat-020 §10 deferrals.
 from __future__ import annotations
 
 import asyncio
+import json
 import time
 from collections.abc import AsyncIterator, Callable
 from typing import Any, Literal
@@ -36,6 +37,7 @@ from agentforge_core.production.exceptions import (
     GuardrailViolation,
 )
 from agentforge_core.values.chat import ChatChunk, ChatResponse, ChatTurn, StreamingEvent
+from agentforge_core.values.messages import ToolCall
 
 from agentforge_chat._idempotency import IdempotencyCache
 from agentforge_chat._locks import (
@@ -74,6 +76,7 @@ class ChatSession:
         on_turn: OnTurnHook | None = None,
         session_lock_factory: SessionLockFactory | None = None,
         safety_mode: SafetyMode = "buffer-then-stream",
+        persist_steps: bool = True,
     ) -> None:
         self._agent = agent
         self._session_id = session_id if session_id is not None else uuid4().hex
@@ -97,6 +100,7 @@ class ChatSession:
         self._turn_count = 0
         self._closed = False
         self._safety_mode: SafetyMode = safety_mode
+        self._persist_steps = persist_steps
 
     # ------------------------------------------------------------------
     # Public properties
@@ -200,13 +204,17 @@ class ChatSession:
         result = await self._agent.run(task)
         duration_ms = int((time.monotonic() - start) * 1000)
         validated_out = await self._agent._guardrails.check_output(self._extract_text(result), ctx)
+        # Persist intermediate tool steps BEFORE the final assistant turn so
+        # the chat history reflects causal ordering (user → tool calls →
+        # tool results → final answer). bug-010.
+        tool_calls = await self._persist_steps_from_result(result)
         assistant_turn = await self._persist_assistant(validated_out, result, duration_ms)
         self._enforce_budgets(result.cost_usd)
         response = ChatResponse(
             content=validated_out,
             turn_id=assistant_turn.id,
             run_id=result.run_id,
-            tool_calls=(),
+            tool_calls=tool_calls,
             tokens_in=result.tokens_in,
             tokens_out=result.tokens_out,
             cost_usd=result.cost_usd,
@@ -254,6 +262,103 @@ class ChatSession:
             return output
         return str(output)
 
+    async def _persist_steps_from_result(self, result: Any) -> tuple[ToolCall, ...]:
+        """Persist `act` and `observe` steps from `result.steps` as
+        `ChatTurn`s ahead of the final assistant turn (bug-010).
+
+        Returns the aggregated tool_calls so the caller can attach them
+        to both the final assistant `ChatTurn.tool_calls` and the
+        synchronous `ChatResponse.tool_calls`. No-op when
+        `self._persist_steps` is False.
+        """
+        if not self._persist_steps:
+            return ()
+        tool_calls: list[ToolCall] = []
+        for step in result.steps:
+            if step.tool_call is None:
+                continue
+            if step.kind == "act":
+                tool_calls.append(step.tool_call)
+                content = (
+                    step.content if isinstance(step.content, str) else json.dumps(step.content)
+                )
+                turn = ChatTurn(
+                    id=uuid4().hex,
+                    session_id=self._session_id,
+                    role="assistant",
+                    content=content,
+                    run_id=result.run_id,
+                    tool_calls=(step.tool_call,),
+                    tokens_in=step.tokens_in,
+                    tokens_out=step.tokens_out,
+                    cost_usd=step.cost_usd,
+                )
+                await self._history.append(turn)
+                if self._on_turn is not None:
+                    self._on_turn(turn)
+            elif step.kind == "observe":
+                content = (
+                    step.content if isinstance(step.content, str) else json.dumps(step.content)
+                )
+                turn = ChatTurn(
+                    id=uuid4().hex,
+                    session_id=self._session_id,
+                    role="tool",
+                    content=content,
+                    tool_call_id=step.tool_call.id,
+                    run_id=result.run_id,
+                )
+                await self._history.append(turn)
+                if self._on_turn is not None:
+                    self._on_turn(turn)
+        return tuple(tool_calls)
+
+    async def _persist_steps_from_events(
+        self,
+        events: list[StreamingEvent],
+        *,
+        run_id: str,
+    ) -> None:
+        """Stream-path mirror of `_persist_steps_from_result` (bug-010).
+
+        Walks the buffered `kind="step"` events captured during
+        `agent.stream(...)`. `tool_call` rides on `event.metadata` as a
+        serialised dict (see `strategies._base._events_for_new_steps`)
+        so the session can persist tool turns without reaching into
+        `AgentState`.
+        """
+        if not self._persist_steps:
+            return
+        for event in events:
+            meta = event.metadata
+            kind = meta.get("kind")
+            tool_call_dict = meta.get("tool_call")
+            if kind not in ("act", "observe") or not isinstance(tool_call_dict, dict):
+                continue
+            tool_call = ToolCall.model_validate(tool_call_dict)
+            content = event.content if isinstance(event.content, str) else json.dumps(event.content)
+            if kind == "act":
+                turn = ChatTurn(
+                    id=uuid4().hex,
+                    session_id=self._session_id,
+                    role="assistant",
+                    content=content,
+                    run_id=run_id,
+                    tool_calls=(tool_call,),
+                )
+            else:  # observe
+                turn = ChatTurn(
+                    id=uuid4().hex,
+                    session_id=self._session_id,
+                    role="tool",
+                    content=content,
+                    tool_call_id=tool_call.id,
+                    run_id=run_id,
+                )
+            await self._history.append(turn)
+            if self._on_turn is not None:
+                self._on_turn(turn)
+
     async def _persist_assistant(
         self,
         text: str,
@@ -343,7 +448,7 @@ class ChatSession:
             async for chunk in self._chunks_for(response):
                 yield chunk
 
-    async def _stream_per_token(  # noqa: PLR0912
+    async def _stream_per_token(  # noqa: PLR0912, PLR0915
         self,
         message: str,
         *,
@@ -370,6 +475,10 @@ class ChatSession:
         assistant_turn_id = uuid4().hex
         cumulative = ""
         run_summary: dict[str, Any] | None = None
+        # Collected step events (bug-010): persisted as ChatTurns after
+        # the stream finishes but before the final assistant turn, so
+        # tool calls + results appear in causal order on disk.
+        step_events: list[StreamingEvent] = []
         start = time.monotonic()
         buffered = self._safety_mode in ("sentence-window", "stream-then-redact")
         window = _SentenceWindowBuffer() if buffered else None
@@ -381,6 +490,8 @@ class ChatSession:
                 # event and complete naturally so `Agent.stream`'s
                 # `finally: reset_run(token)` fires deterministically.
                 continue
+            if event.kind == "step":
+                step_events.append(event)
             if event.kind == "text" and isinstance(event.content, str):
                 if window is not None:
                     for sentence in window.push(event.content):
@@ -431,6 +542,11 @@ class ChatSession:
                 else cumulative
             )
             validated_out = await self._agent._guardrails.check_output(final_text, ctx)
+        # Persist intermediate tool steps before the final assistant
+        # turn (bug-010, stream path mirror of `_persist_steps_from_result`).
+        await self._persist_steps_from_events(
+            step_events, run_id=str(run_summary.get("run_id", ""))
+        )
         assistant_turn = ChatTurn(
             id=assistant_turn_id,
             session_id=self._session_id,

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/src/agentforge_chat/sqlite.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 import json
 from collections.abc import Mapping
-from datetime import datetime
+from datetime import UTC, datetime
 from pathlib import Path
 from types import TracebackType
 from typing import Any
@@ -200,12 +200,24 @@ class SqliteChatHistory(ChatHistoryStore):
         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:
+        # Create the session row if it doesn't exist yet (bug-018):
+        # ChatServer records owner/metadata before the first turn is
+        # appended. DO NOTHING leaves an existing row (and its
+        # last_active_at) untouched.
+        now_iso = datetime.now(UTC).isoformat()
+        await self._db.execute(
+            """INSERT INTO chat_sessions
+               (id, owner, created_at, last_active_at, metadata)
+               VALUES (?, NULL, ?, ?, ?)
+               ON CONFLICT(id) DO NOTHING""",
+            (session_id, now_iso, now_iso, "{}"),
+        )
         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:
+        if row is None:  # pragma: no cover — the INSERT above guarantees a row
             raise ModuleError(f"Cannot update metadata for unknown session {session_id!r}")
         existing = json.loads(row["metadata"])
         existing.update(dict(metadata))

{agentforge_chat-0.2.2 → agentforge_chat-0.2.4}/tests/unit/test_session.py

@@ -19,6 +19,7 @@ from agentforge_core.values.messages import (
     LLMResponse,
     Message,
     TokenUsage,
+    ToolCall,
     ToolSpec,
 )
 from agentforge_core.values.state import AgentState, Step
@@ -241,3 +242,110 @@ async def test_close_is_idempotent() -> None:
     session = _session(session_id="t14")
     await session.close()
     await session.close()
+
+
+# ----------------------------------------------------------------------
+# bug-010 — persist intermediate tool steps to history
+# ----------------------------------------------------------------------
+
+
+class _ToolUseStrategy(ReasoningStrategy):
+    """Strategy that simulates one think/act/observe iteration with a
+    tool call, then a final think with the answer. Used to exercise
+    bug-010 persistence."""
+
+    def __init__(self, *, tool_id: str = "tc-1", tool_name: str = "ping") -> None:
+        self._tool_id = tool_id
+        self._tool_name = tool_name
+
+    async def run(self, state: AgentState) -> AgentState:
+        runtime = state.metadata.get(RUNTIME_KEY)
+        if runtime is not None:
+            runtime.budget.commit(0.01)
+        tc = ToolCall(id=self._tool_id, name=self._tool_name, arguments={"target": "x"})
+        state.steps.append(Step(iteration=0, kind="think", content="planning"))
+        state.steps.append(
+            Step(
+                iteration=0,
+                kind="act",
+                content={"tool": tc.name, "arguments": dict(tc.arguments)},
+                tool_call=tc,
+                cost_usd=0.0,
+            )
+        )
+        state.steps.append(
+            Step(
+                iteration=0,
+                kind="observe",
+                content='{"ok": true}',
+                tool_call=tc,
+                cost_usd=0.0,
+            )
+        )
+        state.steps.append(
+            Step(iteration=1, kind="think", content="all good", cost_usd=0.01),
+        )
+        return state
+
+
+def _tool_session(**kwargs: Any) -> ChatSession:
+    agent = Agent(model=_FakeLLM(), strategy=_ToolUseStrategy())
+    return ChatSession(agent, history_store=InMemoryChatHistory(), **kwargs)
+
+
+@pytest.mark.asyncio
+async def test_persist_steps_records_act_and_observe_turns() -> None:
+    """bug-010: tool steps from result.steps must persist to chat history
+    so generative-UI clients can render them and the next turn's prompt
+    sees prior tool context."""
+    session = _tool_session(session_id="t-bug010-run")
+    await session.send("do the thing")
+    turns = await session.history()
+    roles_then_ids = [(t.role, t.tool_call_id, t.tool_calls) for t in turns]
+    # Expected shape: user, assistant(act with tool_calls), tool(observation),
+    # assistant(final answer).
+    assert [r for r, _, _ in roles_then_ids] == ["user", "assistant", "tool", "assistant"]
+    _, _, act_tcs = roles_then_ids[1]
+    assert len(act_tcs) == 1
+    assert act_tcs[0].id == "tc-1"
+    assert act_tcs[0].name == "ping"
+    _, observe_tcid, _ = roles_then_ids[2]
+    assert observe_tcid == "tc-1"
+
+
+@pytest.mark.asyncio
+async def test_response_tool_calls_populated_from_steps() -> None:
+    """bug-010: ChatResponse.tool_calls aggregates the tool calls from
+    `result.steps` instead of being the previously-hardcoded empty tuple."""
+    session = _tool_session(session_id="t-bug010-resp")
+    response = await session.send("do the thing")
+    assert len(response.tool_calls) == 1
+    assert response.tool_calls[0].id == "tc-1"
+
+
+@pytest.mark.asyncio
+async def test_persist_steps_false_keeps_history_lean() -> None:
+    """bug-010 opt-out: setting persist_steps=False reverts to the
+    pre-fix shape (user + final assistant only). Useful when an
+    external consumer reconstructs tool history from another source."""
+    session = _tool_session(session_id="t-bug010-off", persist_steps=False)
+    response = await session.send("do the thing")
+    turns = await session.history()
+    assert [t.role for t in turns] == ["user", "assistant"]
+    # And the response still surfaces an empty tool_calls (opt-out is
+    # consistent across persistence + response).
+    assert response.tool_calls == ()
+
+
+@pytest.mark.asyncio
+async def test_stream_persists_step_turns() -> None:
+    """bug-010 stream path: `_stream_per_token` must persist tool turns
+    via `_persist_steps_from_events` so streaming and non-streaming
+    paths produce the same on-disk shape."""
+    session = _tool_session(session_id="t-bug010-stream")
+    async for _ in await session.stream("do the thing"):
+        pass
+    turns = await session.history()
+    assert [t.role for t in turns] == ["user", "assistant", "tool", "assistant"]
+    # tool turn pairs by id with the prior assistant turn's tool_calls
+    assert turns[1].tool_calls[0].id == turns[2].tool_call_id