agent-starter-pack 0.3.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

src/frontends/streamlit/frontend/streamlit_app.py

@@ -1,265 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# mypy: disable-error-code="arg-type"
-import json
-import uuid
-from collections.abc import Sequence
-from functools import partial
-from typing import Any
-
-import streamlit as st
-from langchain_core.messages import HumanMessage
-from streamlit_feedback import streamlit_feedback
-
-from frontend.side_bar import SideBar
-from frontend.style.app_markdown import MARKDOWN_STR
-from frontend.utils.local_chat_history import LocalChatMessageHistory
-from frontend.utils.message_editing import MessageEditing
-from frontend.utils.multimodal_utils import format_content, get_parts_from_files
-from frontend.utils.stream_handler import Client, StreamHandler, get_chain_response
-
-USER = "my_user"
-EMPTY_CHAT_NAME = "Empty chat"
-
-
-def setup_page() -> None:
-    """Configure the Streamlit page settings."""
-    st.set_page_config(
-        page_title="Playground",
-        layout="wide",
-        initial_sidebar_state="auto",
-        menu_items=None,
-    )
-    st.title("Playground")
-    st.markdown(MARKDOWN_STR, unsafe_allow_html=True)
-
-
-def initialize_session_state() -> None:
-    """Initialize the session state with default values."""
-    if "user_chats" not in st.session_state:
-        st.session_state["session_id"] = str(uuid.uuid4())
-        st.session_state.uploader_key = 0
-        st.session_state.run_id = None
-        st.session_state.user_id = USER
-        st.session_state["gcs_uris_to_be_sent"] = ""
-        st.session_state.modified_prompt = None
-        st.session_state.session_db = LocalChatMessageHistory(
-            session_id=st.session_state["session_id"],
-            user_id=st.session_state["user_id"],
-        )
-        st.session_state.user_chats = (
-            st.session_state.session_db.get_all_conversations()
-        )
-        st.session_state.user_chats[st.session_state["session_id"]] = {
-            "title": EMPTY_CHAT_NAME,
-            "messages": [],
-        }
-
-
-def display_messages() -> None:
-    """Display all messages in the current chat session."""
-    messages = st.session_state.user_chats[st.session_state["session_id"]]["messages"]
-    tool_calls_map = {}  # Map tool_call_id to tool call input
-
-    for i, message in enumerate(messages):
-        if message["type"] in ["ai", "human"] and message["content"]:
-            display_chat_message(message, i)
-        elif message.get("tool_calls"):
-            # Store each tool call input mapped by its ID
-            for tool_call in message["tool_calls"]:
-                tool_calls_map[tool_call["id"]] = tool_call
-        elif message["type"] == "tool":
-            # Look up the corresponding tool call input by ID
-            tool_call_id = message["tool_call_id"]
-            if tool_call_id in tool_calls_map:
-                display_tool_output(tool_calls_map[tool_call_id], message)
-            else:
-                st.error(f"Could not find tool call input for ID: {tool_call_id}")
-        else:
-            st.error(f"Unexpected message type: {message['type']}")
-            st.write("Full messages list:", messages)
-            raise ValueError(f"Unexpected message type: {message['type']}")
-
-
-def display_chat_message(message: dict[str, Any], index: int) -> None:
-    """Display a single chat message with edit, refresh, and delete options."""
-    chat_message = st.chat_message(message["type"])
-    with chat_message:
-        st.markdown(format_content(message["content"]), unsafe_allow_html=True)
-        col1, col2, col3 = st.columns([2, 2, 94])
-        display_message_buttons(message, index, col1, col2, col3)
-
-
-def display_message_buttons(
-    message: dict[str, Any], index: int, col1: Any, col2: Any, col3: Any
-) -> None:
-    """Display edit, refresh, and delete buttons for a chat message."""
-    edit_button = f"{index}_edit"
-    refresh_button = f"{index}_refresh"
-    delete_button = f"{index}_delete"
-    content = (
-        message["content"]
-        if isinstance(message["content"], str)
-        else message["content"][-1]["text"]
-    )
-
-    with col1:
-        st.button(label="✎", key=edit_button, type="primary")
-    if message["type"] == "human":
-        with col2:
-            st.button(
-                label="⟳",
-                key=refresh_button,
-                type="primary",
-                on_click=partial(MessageEditing.refresh_message, st, index, content),
-            )
-        with col3:
-            st.button(
-                label="X",
-                key=delete_button,
-                type="primary",
-                on_click=partial(MessageEditing.delete_message, st, index),
-            )
-
-    if st.session_state[edit_button]:
-        st.text_area(
-            "Edit your message:",
-            value=content,
-            key=f"edit_box_{index}",
-            on_change=partial(MessageEditing.edit_message, st, index, message["type"]),
-        )
-
-
-def display_tool_output(
-    tool_call_input: dict[str, Any], tool_call_output: dict[str, Any]
-) -> None:
-    """Display the input and output of a tool call in an expander."""
-    tool_expander = st.expander(label="Tool Calls:", expanded=False)
-    with tool_expander:
-        msg = (
-            f"\n\nEnding tool: `{tool_call_input}` with\n **args:**\n"
-            f"```\n{json.dumps(tool_call_input, indent=2)}\n```\n"
-            f"\n\n**output:**\n "
-            f"```\n{json.dumps(tool_call_output, indent=2)}\n```"
-        )
-        st.markdown(msg, unsafe_allow_html=True)
-
-
-def handle_user_input(side_bar: SideBar) -> None:
-    """Process user input, generate AI response, and update chat history."""
-    prompt = st.chat_input() or st.session_state.modified_prompt
-    if prompt:
-        st.session_state.modified_prompt = None
-        parts = get_parts_from_files(
-            upload_gcs_checkbox=st.session_state.checkbox_state,
-            uploaded_files=side_bar.uploaded_files,
-            gcs_uris=side_bar.gcs_uris,
-        )
-        st.session_state["gcs_uris_to_be_sent"] = ""
-        parts.append({"type": "text", "text": prompt})
-        st.session_state.user_chats[st.session_state["session_id"]]["messages"].append(
-            HumanMessage(content=parts).model_dump()
-        )
-
-        display_user_input(parts)
-        generate_ai_response(
-            remote_agent_engine_id=side_bar.remote_agent_engine_id,
-            agent_callable_path=side_bar.agent_callable_path,
-            url=side_bar.url_input_field,
-            authenticate_request=side_bar.should_authenticate_request,
-        )
-        update_chat_title()
-        if len(parts) > 1:
-            st.session_state.uploader_key += 1
-        st.rerun()
-
-
-def display_user_input(parts: Sequence[dict[str, Any]]) -> None:
-    """Display the user's input in the chat interface."""
-    human_message = st.chat_message("human")
-    with human_message:
-        existing_user_input = format_content(parts)
-        st.markdown(existing_user_input, unsafe_allow_html=True)
-
-
-def generate_ai_response(
-    remote_agent_engine_id: str | None = None,
-    agent_callable_path: str | None = None,
-    url: str | None = None,
-    authenticate_request: bool = False,
-) -> None:
-    """Generate and display the AI's response to the user's input."""
-    ai_message = st.chat_message("ai")
-    with ai_message:
-        status = st.status("Generating answer🤖")
-        stream_handler = StreamHandler(st=st)
-        client = Client(
-            remote_agent_engine_id=remote_agent_engine_id,
-            agent_callable_path=agent_callable_path,
-            url=url,
-            authenticate_request=authenticate_request,
-        )
-        get_chain_response(st=st, client=client, stream_handler=stream_handler)
-        status.update(label="Finished!", state="complete", expanded=False)
-
-
-def update_chat_title() -> None:
-    """Update the chat title if it's currently empty."""
-    if (
-        st.session_state.user_chats[st.session_state["session_id"]]["title"]
-        == EMPTY_CHAT_NAME
-    ):
-        st.session_state.session_db.set_title(
-            st.session_state.user_chats[st.session_state["session_id"]]
-        )
-    st.session_state.session_db.upsert_session(
-        st.session_state.user_chats[st.session_state["session_id"]]
-    )
-
-
-def display_feedback(side_bar: SideBar) -> None:
-    """Display a feedback component and log the feedback if provided."""
-    if st.session_state.run_id is not None:
-        feedback = streamlit_feedback(
-            feedback_type="faces",
-            optional_text_label="[Optional] Please provide an explanation",
-            key=f"feedback-{st.session_state.run_id}",
-        )
-        if feedback is not None:
-            client = Client(
-                remote_agent_engine_id=side_bar.remote_agent_engine_id,
-                agent_callable_path=side_bar.agent_callable_path,
-                url=side_bar.url_input_field,
-                authenticate_request=side_bar.should_authenticate_request,
-            )
-            client.log_feedback(
-                feedback_dict=feedback,
-                run_id=st.session_state.run_id,
-            )
-
-
-def main() -> None:
-    """Main function to set up and run the Streamlit app."""
-    setup_page()
-    initialize_session_state()
-    side_bar = SideBar(st=st)
-    side_bar.init_side_bar()
-    display_messages()
-    handle_user_input(side_bar=side_bar)
-    display_feedback(side_bar=side_bar)
-
-
-if __name__ == "__main__":
-    main()

src/frontends/streamlit/frontend/style/app_markdown.py

@@ -1,37 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-MARKDOWN_STR = """
-<style>
-button[kind="primary"] {
-    background: none!important;
-    border: 0;
-    padding: 20!important;
-    color: grey !important;
-    text-decoration: none;
-    cursor: pointer;
-    border: none !important;
-    # float: right;
-}
-button[kind="primary"]:hover {
-    text-decoration: none;
-    color: white !important;
-}
-button[kind="primary"]:focus {
-    outline: none !important;
-    box-shadow: none !important;
-    color:  !important;
-}
-</style>
-"""

src/frontends/streamlit/frontend/utils/chat_utils.py

@@ -1,67 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-SAVED_CHAT_PATH = str(os.getcwd()) + "/.saved_chats"
-
-
-def clean_text(text: str) -> str:
-    """Preprocess the input text by removing leading and trailing newlines."""
-    if not text:
-        return text
-
-    if text.startswith("\n"):
-        text = text[1:]
-    if text.endswith("\n"):
-        text = text[:-1]
-    return text
-
-
-def sanitize_messages(
-    messages: list[dict[str, str | list[dict[str, str]]]],
-) -> list[dict[str, str | list[dict[str, str]]]]:
-    """Preprocess and fix the content of messages."""
-    for message in messages:
-        if isinstance(message["content"], list):
-            for part in message["content"]:
-                if part["type"] == "text":
-                    part["text"] = clean_text(part["text"])
-        else:
-            message["content"] = clean_text(message["content"])
-    return messages
-
-
-def save_chat(st: Any) -> None:
-    """Save the current chat session to a YAML file."""
-    Path(SAVED_CHAT_PATH).mkdir(parents=True, exist_ok=True)
-    session_id = st.session_state["session_id"]
-    session = st.session_state.user_chats[session_id]
-    messages = session.get("messages", [])
-    if len(messages) > 0:
-        session["messages"] = sanitize_messages(session["messages"])
-        filename = f"{session_id}.yaml"
-        with open(Path(SAVED_CHAT_PATH) / filename, "w") as file:
-            yaml.dump(
-                [session],
-                file,
-                allow_unicode=True,
-                default_flow_style=False,
-                encoding="utf-8",
-            )
-        st.toast(f"Chat saved to path: ↓ {Path(SAVED_CHAT_PATH) / filename}")

src/frontends/streamlit/frontend/utils/local_chat_history.py

@@ -1,125 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-from datetime import datetime
-
-import yaml
-from langchain_core.chat_history import BaseChatMessageHistory
-
-from frontend.utils.title_summary import chain_title
-
-
-class LocalChatMessageHistory(BaseChatMessageHistory):
-    """Manages local storage and retrieval of chat message history."""
-
-    def __init__(
-        self,
-        user_id: str,
-        session_id: str = "default",
-        base_dir: str = ".streamlit_chats",
-    ) -> None:
-        self.user_id = user_id
-        self.session_id = session_id
-        self.base_dir = base_dir
-        self.user_dir = os.path.join(self.base_dir, self.user_id)
-        self.session_file = os.path.join(self.user_dir, f"{session_id}.yaml")
-
-        os.makedirs(self.user_dir, exist_ok=True)
-
-    def get_session(self, session_id: str) -> None:
-        """Updates the session ID and file path for the current session."""
-        self.session_id = session_id
-        self.session_file = os.path.join(self.user_dir, f"{session_id}.yaml")
-
-    def get_all_conversations(self) -> dict[str, dict]:
-        """Retrieves all conversations for the current user."""
-        conversations = {}
-        for filename in os.listdir(self.user_dir):
-            if filename.endswith(".yaml"):
-                file_path = os.path.join(self.user_dir, filename)
-                with open(file_path) as f:
-                    conversation = yaml.safe_load(f)
-                    if not isinstance(conversation, list) or len(conversation) > 1:
-                        raise ValueError(
-                            f"""Invalid format in {file_path}.
-                        YAML file can only contain one conversation with the following
-                        structure.
-                          - messages:
-                              - content: [message text]
-                              - type: (human or ai)"""
-                        )
-                    conversation = conversation[0]
-                    if "title" not in conversation:
-                        conversation["title"] = filename
-                conversations[filename[:-5]] = conversation
-        return dict(
-            sorted(conversations.items(), key=lambda x: x[1].get("update_time", ""))
-        )
-
-    def upsert_session(self, session: dict) -> None:
-        """Updates or inserts a session into the local storage."""
-        session["update_time"] = datetime.now().isoformat()
-        with open(self.session_file, "w") as f:
-            yaml.dump(
-                [session],
-                f,
-                allow_unicode=True,
-                default_flow_style=False,
-                encoding="utf-8",
-            )
-
-    def set_title(self, session: dict) -> None:
-        """
-        Set the title for the given session.
-
-        This method generates a title for the session based on its messages.
-        If the session has messages, it appends a special message to prompt
-        for title creation, generates the title using a title chain, and
-        updates the session with the new title.
-
-        Args:
-            session (dict): A dictionary containing session information,
-                            including messages.
-
-        Returns:
-            None
-        """
-        if session["messages"]:
-            messages = session["messages"] + [
-                {
-                    "type": "human",
-                    "content": "End of conversation - Create one single title",
-                }
-            ]
-            # Remove the tool calls from conversation
-            messages = [
-                msg
-                for msg in messages
-                if msg["type"] in ("ai", "human") and isinstance(msg["content"], str)
-            ]
-
-            response = chain_title.invoke(messages)
-            title = (
-                response.content.strip()
-                if isinstance(response.content, str)
-                else str(response.content)
-            )
-            session["title"] = title
-            self.upsert_session(session)
-
-    def clear(self) -> None:
-        """Removes the current session file if it exists."""
-        if os.path.exists(self.session_file):
-            os.remove(self.session_file)

src/frontends/streamlit/frontend/utils/message_editing.py

@@ -1,59 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# fmt: off
-
-from typing import Any
-
-
-class MessageEditing:
-    """Provides methods for editing, refreshing, and deleting chat messages."""
-
-    @staticmethod
-    def edit_message(st: Any, button_idx: int, message_type: str) -> None:
-        """Edit a message in the chat history."""
-        button_id = f"edit_box_{button_idx}"
-        if message_type == "human":
-            messages = st.session_state.user_chats[st.session_state["session_id"]][
-                "messages"
-            ]
-            st.session_state.user_chats[st.session_state["session_id"]][
-                "messages"
-            ] = messages[:button_idx]
-            st.session_state.modified_prompt = st.session_state[button_id]
-        else:
-            st.session_state.user_chats[st.session_state["session_id"]]["messages"][
-                button_idx
-            ]["content"] = st.session_state[button_id]
-
-    @staticmethod
-    def refresh_message(st: Any, button_idx: int, content: str) -> None:
-        """Refresh a message in the chat history."""
-        messages = st.session_state.user_chats[st.session_state["session_id"]][
-            "messages"
-        ]
-        st.session_state.user_chats[st.session_state["session_id"]][
-            "messages"
-        ] = messages[:button_idx]
-        st.session_state.modified_prompt = content
-
-    @staticmethod
-    def delete_message(st: Any, button_idx: int) -> None:
-        """Delete a message from the chat history."""
-        messages = st.session_state.user_chats[st.session_state["session_id"]][
-            "messages"
-        ]
-        st.session_state.user_chats[st.session_state["session_id"]][
-            "messages"
-        ] = messages[:button_idx]