youngjin-langchain-tools 0.1.2__tar.gz → 0.1.4__tar.gz

{youngjin_langchain_tools-0.1.2 → youngjin_langchain_tools-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: youngjin-langchain-tools
-Version: 0.1.2
+Version: 0.1.4
 Summary: LangGraph utilities for Streamlit - StreamlitLanggraphHandler and more
 Project-URL: Homepage, https://github.com/yourusername/youngjin-langchain-tools
 Project-URL: Documentation, https://github.com/yourusername/youngjin-langchain-tools#readme

{youngjin_langchain_tools-0.1.2 → youngjin_langchain_tools-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "youngjin-langchain-tools"
-version = "0.1.2"
+version = "0.1.4"
 description = "LangGraph utilities for Streamlit - StreamlitLanggraphHandler and more"
 readme = "README.md"
 requires-python = ">=3.10"

{youngjin_langchain_tools-0.1.2 → youngjin_langchain_tools-0.1.4}/youngjin_langchain_tools/handlers/streamlit_langgraph_handler.py

@@ -8,8 +8,8 @@ LangGraph agent responses in Streamlit applications.
 Replaces the deprecated StreamlitCallbackHandler for LangGraph-based agents.
 """
 
-from typing import Any, Dict, List, Optional, Union, Generator
-from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Generator
+from dataclasses import dataclass
 import logging
 import re
 
@@ -129,6 +129,13 @@ class StreamlitLanggraphHandlerConfig:
     expand_new_thoughts: bool = True
     """Whether to expand the status container to show tool calls."""
 
+    collapse_completed_thoughts: bool = True
+    """Whether to automatically collapse completed thought containers."""
+
+    max_thought_containers: int = 4
+    """Maximum number of thought containers to show at once.
+    When exceeded, oldest thoughts are moved to a 'History' expander."""
+
     max_tool_content_length: int = 2000
     """Maximum length of tool output to display before truncating."""
 
@@ -202,6 +209,8 @@ class StreamlitLanggraphHandler:
         container: Any,
         *,
         expand_new_thoughts: bool = True,
+        collapse_completed_thoughts: bool = True,
+        max_thought_containers: int = 4,
         max_tool_content_length: int = 2000,
         show_tool_calls: bool = True,
         show_tool_results: bool = True,
@@ -217,6 +226,11 @@ class StreamlitLanggraphHandler:
                        Usually st.container() or similar.
             expand_new_thoughts: Whether to expand status container
                                  to show tool calls. Defaults to True.
+            collapse_completed_thoughts: Whether to collapse completed
+                                         thought containers. Defaults to True.
+            max_thought_containers: Maximum number of thought containers
+                                    to show at once. Oldest are moved to
+                                    'History' expander. Defaults to 4.
             max_tool_content_length: Maximum characters of tool output
                                      to display. Defaults to 2000.
             show_tool_calls: Whether to show tool call info. Defaults to True.
@@ -230,6 +244,8 @@ class StreamlitLanggraphHandler:
         else:
             self._config = StreamlitLanggraphHandlerConfig(
                 expand_new_thoughts=expand_new_thoughts,
+                collapse_completed_thoughts=collapse_completed_thoughts,
+                max_thought_containers=max_thought_containers,
                 max_tool_content_length=max_tool_content_length,
                 show_tool_calls=show_tool_calls,
                 show_tool_results=show_tool_results,
@@ -241,6 +257,9 @@ class StreamlitLanggraphHandler:
         self._final_response: str = ""
         self._status_container: Any = None
         self._response_placeholder: Any = None
+        self._thoughts_placeholder: Any = None  # Placeholder for thoughts area
+        self._thought_history: List[Dict[str, Any]] = []  # History of old thoughts
+        self._current_thoughts: List[Dict[str, Any]] = []  # Current visible thoughts
 
     @property
     def config(self) -> StreamlitLanggraphHandlerConfig:
@@ -332,9 +351,13 @@ class StreamlitLanggraphHandler:
 
         # Reset state
         self._final_response = ""
+        self._thought_history = []
+        self._current_thoughts = []
 
         # Create UI components
         with self._container:
+            # Thoughts area placeholder (manages history + current thoughts)
+            self._thoughts_placeholder = st.empty()
             self._status_container = st.status(
                 self._config.thinking_label,
                 expanded=self._config.expand_new_thoughts
@@ -405,16 +428,75 @@ class StreamlitLanggraphHandler:
 
         yield {"type": "complete", "data": {"response": self._final_response}}
 
+    def _add_thought(self, thought_type: str, data: Dict[str, Any]) -> None:
+        """Add a thought and manage history if max_thought_containers exceeded."""
+        thought = {"type": thought_type, "data": data}
+        self._current_thoughts.append(thought)
+
+        # Check if we need to move old thoughts to history
+        max_containers = self._config.max_thought_containers
+        if len(self._current_thoughts) > max_containers:
+            # Move oldest thoughts to history
+            while len(self._current_thoughts) > max_containers:
+                old_thought = self._current_thoughts.pop(0)
+                self._thought_history.append(old_thought)
+
+        # Re-render the entire thoughts area
+        self._render_thoughts()
+
+    def _render_thought_item(self, thought: Dict[str, Any], in_history: bool = False) -> None:
+        """Render a single thought item."""
+        import streamlit as st
+
+        if thought["type"] == "tool_call":
+            if self._config.show_tool_calls:
+                st.markdown(
+                    f"{self._config.tool_call_emoji} "
+                    f"**{thought['data']['name']}**: `{thought['data']['args']}`"
+                )
+        elif thought["type"] == "tool_result":
+            if self._config.show_tool_results:
+                tool_name = thought['data']['name']
+                content = thought['data']['content']
+
+                st.markdown(
+                    f"{self._config.tool_complete_emoji} "
+                    f"**{tool_name}** 완료"
+                )
+
+                if in_history:
+                    # Shorter preview in history
+                    max_len = 200
+                else:
+                    max_len = self._config.max_tool_content_length
+
+                expanded = not self._config.collapse_completed_thoughts
+                with st.expander(f"📋 {tool_name} 결과 보기", expanded=expanded if not in_history else False):
+                    if len(content) > max_len:
+                        st.code(content[:max_len] + "\n... (truncated)", language="text")
+                    else:
+                        st.code(content, language="text")
+
+    def _render_thoughts(self) -> None:
+        """Render all thoughts (history + current) in the placeholder."""
+        import streamlit as st
+
+        with self._thoughts_placeholder.container():
+            # Render history expander if there are old thoughts
+            if self._thought_history:
+                with st.expander(f"📜 History ({len(self._thought_history)} items)", expanded=False):
+                    for thought in self._thought_history:
+                        self._render_thought_item(thought, in_history=True)
+
+            # Render current thoughts
+            for thought in self._current_thoughts:
+                self._render_thought_item(thought, in_history=False)
+
     def _handle_updates(
         self,
         data: Dict[str, Any]
     ) -> Generator[Dict[str, Any], None, None]:
         """Handle 'updates' stream mode events."""
-        try:
-            import streamlit as st
-        except ImportError:
-            return
-
         for source, update in data.items():
             if not isinstance(update, dict):
                 continue
@@ -423,48 +505,43 @@ class StreamlitLanggraphHandler:
             for msg in messages:
                 # Handle tool calls
                 if hasattr(msg, 'tool_calls') and msg.tool_calls:
-                    if self._config.show_tool_calls:
-                        for tc in msg.tool_calls:
-                            tool_name = tc.get('name', 'tool')
-                            tool_args = tc.get('args', {})
-
-                            with self._status_container:
-                                st.write(
-                                    f"{self._config.tool_call_emoji} "
-                                    f"**{tool_name}**: `{tool_args}`"
-                                )
-
-                            yield {
-                                "type": "tool_call",
-                                "data": {"name": tool_name, "args": tool_args}
-                            }
+                    for tc in msg.tool_calls:
+                        tool_name = tc.get('name', 'tool')
+                        tool_args = tc.get('args', {})
 
-                # Handle tool results
-                if source == "tools" and hasattr(msg, 'name'):
-                    if self._config.show_tool_results:
-                        tool_name = msg.name
-                        tool_content = str(msg.content) if hasattr(msg, 'content') else ""
-
-                        with self._status_container:
-                            st.write(
-                                f"{self._config.tool_complete_emoji} "
-                                f"**{tool_name}** 완료"
-                            )
-                            with st.expander(f"📋 {tool_name} 결과 보기", expanded=False):
-                                if len(tool_content) > self._config.max_tool_content_length:
-                                    st.code(
-                                        tool_content[:self._config.max_tool_content_length]
-                                        + "\n... (truncated)",
-                                        language="text"
-                                    )
-                                else:
-                                    st.code(tool_content, language="text")
+                        # Add to thought tracking (this triggers re-render)
+                        self._add_thought("tool_call", {"name": tool_name, "args": tool_args})
+
+                        # Update status label to show current action
+                        self._status_container.update(
+                            label=f"{self._config.tool_call_emoji} {tool_name}...",
+                            state="running"
+                        )
 
                         yield {
-                            "type": "tool_result",
-                            "data": {"name": tool_name, "content": tool_content}
+                            "type": "tool_call",
+                            "data": {"name": tool_name, "args": tool_args}
                         }
 
+                # Handle tool results
+                if source == "tools" and hasattr(msg, 'name'):
+                    tool_name = msg.name
+                    tool_content = str(msg.content) if hasattr(msg, 'content') else ""
+
+                    # Add to thought tracking (this triggers re-render)
+                    self._add_thought("tool_result", {"name": tool_name, "content": tool_content})
+
+                    # Update status to show thinking again
+                    self._status_container.update(
+                        label=self._config.thinking_label,
+                        state="running"
+                    )
+
+                    yield {
+                        "type": "tool_result",
+                        "data": {"name": tool_name, "content": tool_content}
+                    }
+
     def _handle_messages(
         self,
         data: tuple