context-forge-cli 0.1.0__tar.gz → 0.2.5__tar.gz

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: context-forge-cli
-Version: 0.1.0
+Version: 0.2.5
 Summary: Session manager and context bridge for agentic CLI tools
 Project-URL: Homepage, https://github.com/emmver/contextforge
 Project-URL: Repository, https://github.com/emmver/contextforge
@@ -30,14 +30,14 @@ Description-Content-Type: text/markdown
 
 **Session manager and context bridge for agentic CLI tools.**
 
-ContextForge (`cf`) tracks sessions from Claude Code, Codex, altimate-code, and other
+ContextForge (`cf`) tracks sessions from Claude Code, Claude Desktop, Codex, Gemini, altimate-code, and other
 agentic CLI tools. It generates plain-English summaries of each session and can compact
 and transfer context from one or more sessions into a new session — within the same tool
 or across different tools.
 
 ## What it does
 
-- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Codex (`~/.codex/state_5.sqlite`), and altimate-code (`~/.local/share/altimate-code/`)
+- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Claude Desktop, Codex (`~/.codex/state_5.sqlite`), Gemini (`~/.gemini/tmp/<project_hash>/chats/`), and altimate-code (`~/.local/share/altimate-code/`)
 - **Generates summaries** of what each session accomplished (with optional Claude API integration)
 - **Compacts context** intelligently, reducing multi-turn conversations to a token-efficient ContextBundle
 - **Transfers context** across tools and sessions (Claude Code → Codex, Codex → altimate-code, etc.)
@@ -47,7 +47,7 @@ or across different tools.
 
 - **Python 3.13+** (ContextForge requires Python 3.13 or later)
 - **uv** or **pipx** (for installation as a tool)
-- At least one of: Claude Code, Codex, or altimate-code installed and with session history
+- At least one of: Claude Code, Claude Desktop, Codex, Gemini, or altimate-code installed and with session history
 
 ## Install
 
@@ -167,6 +167,7 @@ The method is chosen automatically based on token count and whether a target ses
 | Claude Code (CLI) | `~/.claude/projects/` JSONL | `--system-prompt` / `--resume` |
 | Claude Desktop | `~/Library/Application Support/Claude/local-agent-mode-sessions/` | `--system-prompt` |
 | Codex | `~/.codex/state_5.sqlite` | `resume` / `fork` |
+| Gemini | `~/.gemini/tmp/<project_hash>/chats/` JSON | New session / `/resume` |
 | altimate-code | `~/.local/share/altimate-code/opencode.db` | `run -s` / `import` |
 
 ## Session Summaries
@@ -261,7 +262,7 @@ A full-screen Textual dashboard with live session browsing, filtering, and analy
 │                          │ Worked on UTASTAR ensemble      │
 │                          │ pruning framework...            │
 └──────────────────────────┴─────────────────────────────────┘
- Sessions — CC:12 │ Codex:4 │ Alt:3 │ Total:19 │ 129M tok   14:32:01
+ Sessions — CC:12 │ Codex:4 │ Gemini:2 │ Alt:3 │ Total:21 │ 129M tok   14:32:01
 ```
 
 ### Key bindings
@@ -298,7 +299,7 @@ Press `/` to open the filter bar above the session list:
 ### Transfer modal (`t`)
 
 Press `t` on any session to open the transfer panel. Choose:
-- **Target tool** — Claude Code, Codex, or altimate-code
+- **Target tool** — Claude Code, Claude Desktop, Codex, Gemini, or altimate-code
 - **Strategy** — `summary_only`, `key_messages`, or `full_recent`
 - **Preview** — shows the exact shell command (no side effects)
 - **Execute** — builds the bundle and launches the target tool

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/README.md

@@ -2,14 +2,14 @@
 
 **Session manager and context bridge for agentic CLI tools.**
 
-ContextForge (`cf`) tracks sessions from Claude Code, Codex, altimate-code, and other
+ContextForge (`cf`) tracks sessions from Claude Code, Claude Desktop, Codex, Gemini, altimate-code, and other
 agentic CLI tools. It generates plain-English summaries of each session and can compact
 and transfer context from one or more sessions into a new session — within the same tool
 or across different tools.
 
 ## What it does
 
-- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Codex (`~/.codex/state_5.sqlite`), and altimate-code (`~/.local/share/altimate-code/`)
+- **Discovers sessions** from Claude Code (`~/.claude/projects/`), Claude Desktop, Codex (`~/.codex/state_5.sqlite`), Gemini (`~/.gemini/tmp/<project_hash>/chats/`), and altimate-code (`~/.local/share/altimate-code/`)
 - **Generates summaries** of what each session accomplished (with optional Claude API integration)
 - **Compacts context** intelligently, reducing multi-turn conversations to a token-efficient ContextBundle
 - **Transfers context** across tools and sessions (Claude Code → Codex, Codex → altimate-code, etc.)
@@ -19,7 +19,7 @@ or across different tools.
 
 - **Python 3.13+** (ContextForge requires Python 3.13 or later)
 - **uv** or **pipx** (for installation as a tool)
-- At least one of: Claude Code, Codex, or altimate-code installed and with session history
+- At least one of: Claude Code, Claude Desktop, Codex, Gemini, or altimate-code installed and with session history
 
 ## Install
 
@@ -139,6 +139,7 @@ The method is chosen automatically based on token count and whether a target ses
 | Claude Code (CLI) | `~/.claude/projects/` JSONL | `--system-prompt` / `--resume` |
 | Claude Desktop | `~/Library/Application Support/Claude/local-agent-mode-sessions/` | `--system-prompt` |
 | Codex | `~/.codex/state_5.sqlite` | `resume` / `fork` |
+| Gemini | `~/.gemini/tmp/<project_hash>/chats/` JSON | New session / `/resume` |
 | altimate-code | `~/.local/share/altimate-code/opencode.db` | `run -s` / `import` |
 
 ## Session Summaries
@@ -233,7 +234,7 @@ A full-screen Textual dashboard with live session browsing, filtering, and analy
 │                          │ Worked on UTASTAR ensemble      │
 │                          │ pruning framework...            │
 └──────────────────────────┴─────────────────────────────────┘
- Sessions — CC:12 │ Codex:4 │ Alt:3 │ Total:19 │ 129M tok   14:32:01
+ Sessions — CC:12 │ Codex:4 │ Gemini:2 │ Alt:3 │ Total:21 │ 129M tok   14:32:01
 ```
 
 ### Key bindings
@@ -270,7 +271,7 @@ Press `/` to open the filter bar above the session list:
 ### Transfer modal (`t`)
 
 Press `t` on any session to open the transfer panel. Choose:
-- **Target tool** — Claude Code, Codex, or altimate-code
+- **Target tool** — Claude Code, Claude Desktop, Codex, Gemini, or altimate-code
 - **Strategy** — `summary_only`, `key_messages`, or `full_recent`
 - **Preview** — shows the exact shell command (no side effects)
 - **Execute** — builds the bundle and launches the target tool

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/contextforge/adapters/altimate_code.py

@@ -25,6 +25,16 @@ def _count_tokens(text: str) -> int:
         return len(text) // 4
 
 
+def _compute_message_tokens(msg) -> int:
+    """Count tokens across all content: text + tool_call inputs + tool_result outputs."""
+    total = _count_tokens(msg.content)
+    for tc in msg.tool_calls:
+        total += _count_tokens(tc.get("input", ""))
+    for tr in msg.tool_results:
+        total += _count_tokens(tr.get("output", ""))
+    return total
+
+
 class AltimateCodeAdapter(ToolAdapter):
     tool_name = "altimate_code"
     default_paths = [_OPENCODE_DB]
@@ -86,14 +96,22 @@ class AltimateCodeAdapter(ToolAdapter):
             conn = sqlite3.connect(str(_OPENCODE_DB))
             conn.row_factory = sqlite3.Row
             cur = conn.cursor()
-            # Join message + part to get full content
             cur.execute(
                 """
-                SELECT m.role, p.type as part_type, p.content, m.time as ts
+                SELECT
+                    m.id,
+                    json_extract(m.data, '$.role') as role,
+                    m.time_created as ts,
+                    json_extract(p.data, '$.type') as part_type,
+                    json_extract(p.data, '$.text') as text_content,
+                    json_extract(p.data, '$.tool') as tool_name,
+                    json_extract(p.data, '$.callID') as call_id,
+                    json_extract(p.data, '$.state.input') as tool_input,
+                    json_extract(p.data, '$.state.output') as tool_output
                 FROM message m
                 LEFT JOIN part p ON p.message_id = m.id
                 WHERE m.session_id = ?
-                ORDER BY m.time ASC, p.id ASC
+                ORDER BY m.time_created ASC, p.id ASC
                 """,
                 (session_id,),
             )
@@ -103,33 +121,43 @@ class AltimateCodeAdapter(ToolAdapter):
             return []
 
         messages: list[Message] = []
+        current_msg_id: str | None = None
         current_role: str | None = None
         current_parts: list[str] = []
+        current_tool_calls: list[dict] = []
+        current_tool_results: list[dict] = []
         current_ts: datetime | None = None
 
         def flush():
-            nonlocal current_role, current_parts, current_ts
-            if current_role and current_parts:
+            nonlocal current_msg_id, current_role, current_parts, current_ts
+            nonlocal current_tool_calls, current_tool_results
+            if current_role and (current_parts or current_tool_calls):
                 content = "\n".join(p for p in current_parts if p)
-                if content:
-                    messages.append(
-                        Message(
-                            role=current_role,
-                            content=content,
-                            timestamp=current_ts,
-                        )
-                    )
+                msg = Message(
+                    role=current_role,
+                    content=content,
+                    timestamp=current_ts,
+                    tool_calls=list(current_tool_calls),
+                    tool_results=list(current_tool_results),
+                )
+                msg.token_count = _compute_message_tokens(msg)
+                messages.append(msg)
+            current_msg_id = None
             current_role = None
             current_parts = []
+            current_tool_calls = []
+            current_tool_results = []
             current_ts = None
 
         for row in rows:
+            msg_id = row["id"]
             role = row["role"]
             if role not in ("user", "assistant"):
                 continue
 
-            if role != current_role:
+            if msg_id != current_msg_id:
                 flush()
+                current_msg_id = msg_id
                 current_role = role
                 try:
                     current_ts = datetime.fromtimestamp(row["ts"] / 1000, tz=timezone.utc)
@@ -137,28 +165,36 @@ class AltimateCodeAdapter(ToolAdapter):
                     current_ts = None
 
             part_type = row["part_type"] or ""
-            content = row["content"] or ""
 
-            if part_type in ("text", "reasoning") and content:
-                if isinstance(content, str):
+            if part_type in ("text", "reasoning"):
+                content = row["text_content"] or ""
+                if isinstance(content, str) and content:
                     try:
                         parsed = json.loads(content)
                         if isinstance(parsed, dict):
                             content = parsed.get("text", str(parsed))
                     except (json.JSONDecodeError, TypeError):
                         pass
-                current_parts.append(str(content).strip())
+                    content = str(content).strip()
+                    if content:
+                        current_parts.append(content)
+
+            elif part_type == "tool":
+                tool_name = row["tool_name"] or "?"
+                tool_input = row["tool_input"] or ""
+                tool_output = row["tool_output"] or ""
+                # input from json_extract is already a JSON string; keep as-is for token counting
+                current_tool_calls.append({"name": tool_name, "input": tool_input})
+                if tool_output:
+                    current_tool_results.append({"output": tool_output})
 
         flush()
         return messages
 
     def _count_session_tokens(self, session_id: str) -> int:
-        """Count total tokens in a session."""
+        """Count total tokens in a session (text + tool inputs + tool outputs)."""
         messages = self.load_messages(session_id)
-        total = 0
-        for msg in messages:
-            total += _count_tokens(msg.content)
-        return total
+        return sum(msg.token_count or _compute_message_tokens(msg) for msg in messages)
 
     def build_inject_command(
         self,

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/contextforge/adapters/base.py

@@ -5,6 +5,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 
 from contextforge.models.session import Message, Session
+from contextforge.utils.tokens import count_tokens
 
 
 class ToolAdapter(ABC):
@@ -42,3 +43,17 @@ class ToolAdapter(ABC):
     def is_available(self) -> bool:
         """Return True if this tool is installed and its data paths exist."""
         return any(p.exists() for p in self.default_paths)
+
+    def _count_session_tokens(self, session_id: str | Path) -> int:
+        """Count total tokens in a session by loading and summing message tokens.
+
+        This is the default implementation that all adapters can use.
+        Adapters may override this with more efficient implementations.
+        """
+        if isinstance(session_id, Path):
+            session_id = session_id.stem
+        messages = self.load_messages(str(session_id))
+        total = 0
+        for msg in messages:
+            total += msg.token_count or count_tokens(msg.content)
+        return total

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/contextforge/adapters/claude_code.py

@@ -64,6 +64,16 @@ def _count_tokens(text: str) -> int:
         return len(text) // 4
 
 
+def _compute_message_tokens(msg: Message) -> int:
+    """Count tokens across all content in a message: text + tool_call inputs + tool_result outputs."""
+    total = _count_tokens(msg.content)
+    for tc in msg.tool_calls:
+        total += _count_tokens(tc.get("input", ""))
+    for tr in msg.tool_results:
+        total += _count_tokens(tr.get("output", ""))
+    return total
+
+
 class ClaudeCodeAdapter(ToolAdapter):
     tool_name = "claude_code"
     default_paths = [_HISTORY_PATH, _PROJECTS_DIR]
@@ -309,17 +319,6 @@ class ClaudeCodeAdapter(ToolAdapter):
                 role = msg_data.get("role", entry_type)
                 content_raw = msg_data.get("content", "")
 
-                # Skip entries where content is an array of tool results/tool use
-                # (these are Claude's internal messages, not user input or assistant responses)
-                if isinstance(content_raw, list):
-                    # Only include arrays that contain text blocks (actual assistant content)
-                    if not any(block.get("type") == "text" for block in content_raw if isinstance(block, dict)):
-                        continue
-
-                content = _parse_content(content_raw)
-                if not content:
-                    continue
-
                 ts_str = entry.get("timestamp")
                 ts = None
                 if ts_str:
@@ -328,47 +327,80 @@ class ClaudeCodeAdapter(ToolAdapter):
                     except (ValueError, AttributeError):
                         pass
 
-                messages.append(
-                    Message(
-                        role="user" if role == "user" else "assistant",
-                        content=content,
-                        timestamp=ts,
+                if isinstance(content_raw, list):
+                    has_text = any(
+                        isinstance(b, dict) and b.get("type") == "text"
+                        for b in content_raw
+                    )
+                    has_tool_result = any(
+                        isinstance(b, dict) and b.get("type") == "tool_result"
+                        for b in content_raw
                     )
-                )
-
-        return messages
 
-    def _count_session_tokens(self, jsonl_path: Path) -> int:
-        """Count total tokens in a session JSONL file."""
-        total = 0
-        try:
-            with jsonl_path.open() as f:
-                for line in f:
-                    line = line.strip()
-                    if not line:
-                        continue
-                    try:
-                        entry = json.loads(line)
-                    except json.JSONDecodeError:
+                    # tool_result-only user entries: attribute their outputs to the
+                    # last assistant turn (the one that issued the tool calls)
+                    if has_tool_result and not has_text:
+                        if messages and messages[-1].role == "assistant":
+                            last = messages[-1]
+                            for block in content_raw:
+                                if not isinstance(block, dict) or block.get("type") != "tool_result":
+                                    continue
+                                inner = block.get("content", "")
+                                if isinstance(inner, list):
+                                    for item in inner:
+                                        if isinstance(item, dict) and item.get("type") == "text":
+                                            output = item.get("text", "")
+                                            if output:
+                                                last.tool_results.append({"output": output})
+                                elif isinstance(inner, str) and inner:
+                                    last.tool_results.append({"output": inner})
+                            # Recompute token_count now that tool_results have been added
+                            last.token_count = _compute_message_tokens(last)
                         continue
 
-                    entry_type = entry.get("type", "")
-                    if entry_type not in ("user", "assistant"):
-                        continue
+                    # Extract tool_call entries from assistant content arrays
+                    tool_calls: list[dict] = []
+                    if role != "user":
+                        for block in content_raw:
+                            if not isinstance(block, dict) or block.get("type") != "tool_use":
+                                continue
+                            try:
+                                input_str = json.dumps(block.get("input", {}))
+                            except (TypeError, ValueError):
+                                input_str = ""
+                            tool_calls.append({"name": block.get("name", "?"), "input": input_str})
+                else:
+                    tool_calls = []
+
+                content = _parse_content(content_raw)
+                if not content and not tool_calls:
+                    continue
 
-                    msg_data = entry.get("message", {})
-                    content_raw = msg_data.get("content", "")
+                msg = Message(
+                    role="user" if role == "user" else "assistant",
+                    content=content,
+                    timestamp=ts,
+                    tool_calls=tool_calls,
+                )
+                msg.token_count = _compute_message_tokens(msg)
+                messages.append(msg)
 
-                    # Skip tool-result-only arrays (not actual user/assistant content)
-                    if isinstance(content_raw, list):
-                        if not any(block.get("type") == "text" for block in content_raw if isinstance(block, dict)):
-                            continue
+        return messages
+
+    def _count_session_tokens(self, jsonl_path: Path | str) -> int:
+        """Count total tokens in a session JSONL file or session ID.
 
-                    content = _parse_content(content_raw)
-                    if content:
-                        total += _count_tokens(content)
-        except Exception:
-            pass
+        Args:
+            jsonl_path: Either a Path to the JSONL file or a session ID string.
+        """
+        if isinstance(jsonl_path, str):
+            session_id = jsonl_path
+        else:
+            session_id = jsonl_path.stem
+        messages = self.load_messages(session_id)
+        total = 0
+        for msg in messages:
+            total += msg.token_count or _count_tokens(msg.content)
         return total
 
     def build_inject_command(

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/contextforge/adapters/claude_desktop.py

@@ -240,8 +240,12 @@ class ClaudeDesktopAdapter(ToolAdapter):
                         pass
 
                 messages.append(
-                    Message(role="user" if role == "user" else "assistant",
-                            content=content, timestamp=ts)
+                    Message(
+                        role="user" if role == "user" else "assistant",
+                        content=content,
+                        timestamp=ts,
+                        token_count=_count_tokens(content),
+                    )
                 )
         return messages
 
@@ -279,7 +283,12 @@ class ClaudeDesktopAdapter(ToolAdapter):
                     except (ValueError, AttributeError):
                         pass
 
-                messages.append(Message(role=role, content=content, timestamp=ts))
+                messages.append(Message(
+                    role=role,
+                    content=content,
+                    timestamp=ts,
+                    token_count=_count_tokens(content),
+                ))
         return messages
 
     def _count_session_tokens(self, session_id: str) -> int:
@@ -287,7 +296,7 @@ class ClaudeDesktopAdapter(ToolAdapter):
         messages = self.load_messages(session_id)
         total = 0
         for msg in messages:
-            total += _count_tokens(msg.content)
+            total += msg.token_count or _count_tokens(msg.content)
         return total
 
     def build_inject_command(

{context_forge_cli-0.1.0 → context_forge_cli-0.2.5}/contextforge/adapters/codex.py

@@ -7,6 +7,8 @@ import sqlite3
 from datetime import datetime, timezone
 from pathlib import Path
 
+import tiktoken
+
 from contextforge.adapters.base import ToolAdapter
 from contextforge.models.session import Message, Session
 
@@ -29,6 +31,40 @@ _CODEX_SESSIONS_DIR = Path.home() / ".codex" / "sessions"
 _SESSION_INDEX = Path.home() / ".codex" / "session_index.jsonl"
 
 
+def _count_tokens(text: str) -> int:
+    """Count tokens in text using tiktoken for Claude models."""
+    try:
+        enc = tiktoken.encoding_for_model("claude-3-5-sonnet-20241022")
+        return len(enc.encode(text))
+    except Exception:
+        # Fallback: rough estimate (~4 chars per token)
+        return len(text) // 4
+
+
+def _compute_message_tokens(msg: Message) -> int:
+    total = _count_tokens(msg.content)
+    for tc in msg.tool_calls:
+        total += _count_tokens(tc.get("input", ""))
+    for tr in msg.tool_results:
+        total += _count_tokens(tr.get("output", ""))
+    return total
+
+
+def _extract_function_output(raw_output: str) -> str:
+    """Extract the human-readable output from a Codex function_call_output payload.
+
+    The `output` field is a JSON string: {"output": "...", "metadata": {...}}.
+    Returns the inner "output" string, or the raw string on parse failure.
+    """
+    try:
+        parsed = json.loads(raw_output)
+        if isinstance(parsed, dict):
+            return str(parsed.get("output", raw_output))
+    except (json.JSONDecodeError, TypeError):
+        pass
+    return raw_output
+
+
 class CodexAdapter(ToolAdapter):
     tool_name = "codex"
     default_paths = [_CODEX_DB, _CODEX_SESSIONS_DIR]
@@ -75,7 +111,10 @@ class CodexAdapter(ToolAdapter):
                     cwd=row["cwd"] or None,
                     created_at=created,
                     updated_at=updated,
-                    token_count=row["tokens_used"],
+                    # tokens_used in state_5.sqlite is cumulative API billing spend
+                    # (re-sends full context each call), NOT conversation footprint.
+                    # Leave token_count=None so cf refresh computes it from rollout content.
+                    token_count=None,
                     raw_path=row["rollout_path"] or None,
                     status="unknown",
                 )
@@ -172,6 +211,31 @@ class CodexAdapter(ToolAdapter):
 
     def _parse_rollout(self, path: Path) -> list[Message]:
         messages: list[Message] = []
+
+        # Pending tool data for the current assistant turn (buffered until
+        # we see the agent_message that closes the turn).
+        pending_tool_calls: list[dict] = []
+        pending_tool_results: list[dict] = []
+
+        def flush_pending_assistant(text: str = "", ts=None):
+            """Emit an assistant message with any buffered tool data."""
+            nonlocal pending_tool_calls, pending_tool_results
+            if not text and not pending_tool_calls:
+                pending_tool_calls = []
+                pending_tool_results = []
+                return
+            msg = Message(
+                role="assistant",
+                content=text,
+                timestamp=ts,
+                tool_calls=list(pending_tool_calls),
+                tool_results=list(pending_tool_results),
+            )
+            msg.token_count = _compute_message_tokens(msg)
+            messages.append(msg)
+            pending_tool_calls = []
+            pending_tool_results = []
+
         with path.open() as f:
             for line in f:
                 line = line.strip()
@@ -184,20 +248,42 @@ class CodexAdapter(ToolAdapter):
 
                 entry_type = entry.get("type", "")
                 payload = entry.get("payload", {})
+                ts_str = entry.get("timestamp")
+                ts = None
+                if ts_str:
+                    try:
+                        ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+                    except (ValueError, AttributeError):
+                        pass
 
                 if entry_type == "event_msg":
                     msg_type = payload.get("type", "")
-                    # user_message / agent_message are the clean human-facing turns.
-                    # response_item entries are skipped — they contain system context
-                    # injections (AGENTS.md, environment_context) and duplicate content.
                     if msg_type == "user_message":
-                        text = payload.get("message", "")
+                        # New user turn — flush any orphaned tool data first
+                        flush_pending_assistant()
+                        text = str(payload.get("message", ""))
                         if text:
-                            messages.append(Message(role="user", content=str(text)))
+                            msg = Message(role="user", content=text, timestamp=ts)
+                            msg.token_count = _count_tokens(text)
+                            messages.append(msg)
                     elif msg_type == "agent_message":
-                        text = payload.get("message", "")
-                        if text:
-                            messages.append(Message(role="assistant", content=str(text)))
+                        text = str(payload.get("message", ""))
+                        flush_pending_assistant(text=text, ts=ts)
+
+                elif entry_type == "response_item":
+                    item_type = payload.get("type", "")
+                    if item_type == "function_call":
+                        name = payload.get("name", "?")
+                        arguments = payload.get("arguments", "")
+                        pending_tool_calls.append({"name": name, "input": arguments})
+                    elif item_type == "function_call_output":
+                        raw_output = payload.get("output", "")
+                        output = _extract_function_output(raw_output)
+                        if output:
+                            pending_tool_results.append({"output": output})
+
+        # Flush any trailing tool data (e.g. incomplete / aborted turn)
+        flush_pending_assistant()
 
         return messages