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

src/frontends/streamlit_adk/frontend/utils/stream_handler.py

@@ -1,311 +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="unreachable"
-import importlib
-import json
-from collections.abc import Generator
-from typing import Any
-from urllib.parse import urljoin
-
-import google.auth
-import google.auth.transport.requests
-import google.oauth2.id_token
-import requests
-import streamlit as st
-import vertexai
-from google.adk.events.event import Event
-from google.auth.exceptions import DefaultCredentialsError
-from vertexai import agent_engines
-
-from frontend.utils.multimodal_utils import format_content
-
-st.cache_resource.clear()
-
-
-@st.cache_resource
-def get_remote_agent(remote_agent_engine_id: str) -> Any:
-    """Get cached remote agent instance."""
-    # Extract location and engine ID from the full resource ID.
-    parts = remote_agent_engine_id.split("/")
-    project_id = parts[1]
-    location = parts[3]
-    vertexai.init(project=project_id, location=location)
-    return agent_engines.AgentEngine(remote_agent_engine_id)
-
-
-@st.cache_resource
-def get_remote_url_config(url: str, authenticate_request: bool) -> dict[str, Any]:
-    """Get cached remote URL agent configuration."""
-    stream_url = urljoin(url, "stream_messages")
-    creds, _ = google.auth.default()
-    id_token = None
-    if authenticate_request:
-        auth_req = google.auth.transport.requests.Request()
-        try:
-            id_token = google.oauth2.id_token.fetch_id_token(auth_req, stream_url)
-        except DefaultCredentialsError:
-            creds.refresh(auth_req)
-            id_token = creds.id_token
-    return {
-        "url": stream_url,
-        "authenticate_request": authenticate_request,
-        "creds": creds,
-        "id_token": id_token,
-    }
-
-
-@st.cache_resource()
-def get_local_agent(agent_callable_path: str) -> Any:
-    """Get cached local agent instance."""
-    module_path, class_name = agent_callable_path.rsplit(".", 1)
-    module = importlib.import_module(module_path)
-    agent = getattr(module, class_name)()
-    agent.set_up()
-    return agent
-
-
-class Client:
-    """A client for streaming events from a server."""
-
-    def __init__(
-        self,
-        agent_callable_path: str | None = None,
-        remote_agent_engine_id: str | None = None,
-        url: str | None = None,
-        authenticate_request: bool = False,
-    ) -> None:
-        """Initialize the Client with appropriate configuration.
-
-        Args:
-            agent_callable_path: Path to local agent class
-            remote_agent_engine_id: ID of remote Agent engine
-            url: URL for remote service
-            authenticate_request: Whether to authenticate requests to remote URL
-        """
-        if url:
-            remote_config = get_remote_url_config(url, authenticate_request)
-            self.url = remote_config["url"]
-            self.authenticate_request = remote_config["authenticate_request"]
-            self.creds = remote_config["creds"]
-            self.id_token = remote_config["id_token"]
-            self.agent = None
-        elif remote_agent_engine_id:
-            self.agent = get_remote_agent(remote_agent_engine_id)
-            self.url = None
-        else:
-            self.url = None
-            if agent_callable_path is None:
-                raise ValueError("agent_callable_path cannot be None")
-            self.agent = get_local_agent(agent_callable_path)
-
-    def log_feedback(self, feedback_dict: dict[str, Any], invocation_id: str) -> None:
-        """Log user feedback for a specific run."""
-        score = feedback_dict["score"]
-        if score == "😞":
-            score = 0.0
-        elif score == "🙁":
-            score = 0.25
-        elif score == "😐":
-            score = 0.5
-        elif score == "🙂":
-            score = 0.75
-        elif score == "😀":
-            score = 1.0
-        feedback_dict["score"] = score
-        feedback_dict["invocation_id"] = invocation_id
-        feedback_dict["log_type"] = "feedback"
-        # Ensure text field is not None
-        if feedback_dict.get("text") is None:
-            feedback_dict["text"] = ""
-        feedback_dict.pop("type")
-        url = urljoin(self.url, "feedback")
-        headers = {
-            "Content-Type": "application/json",
-        }
-        if self.url:
-            url = urljoin(self.url, "feedback")
-            headers = {
-                "Content-Type": "application/json",
-            }
-            if self.authenticate_request:
-                headers["Authorization"] = f"Bearer {self.id_token}"
-            requests.post(
-                url, data=json.dumps(feedback_dict), headers=headers, timeout=10
-            )
-        elif self.agent is not None:
-            self.agent.register_feedback(feedback=feedback_dict)
-        else:
-            raise ValueError("No agent or URL configured for feedback logging")
-
-    def stream_messages(
-        self, data: dict[str, Any]
-    ) -> Generator[dict[str, Any], None, None]:
-        """Stream events from the server, yielding parsed event data."""
-        if self.url:
-            headers = {
-                "Content-Type": "application/json",
-                "Accept": "text/event-stream",
-            }
-            if self.authenticate_request:
-                headers["Authorization"] = f"Bearer {self.id_token}"
-            with requests.post(
-                self.url, json=data, headers=headers, stream=True, timeout=60
-            ) as response:
-                for line in response.iter_lines():
-                    if line:
-                        try:
-                            event = json.loads(line.decode("utf-8"))
-                            yield event
-                        except json.JSONDecodeError:
-                            print(f"Failed to parse event: {line.decode('utf-8')}")
-        elif self.agent is not None:
-            yield from self.agent.stream_query(**data)
-
-
-class StreamHandler:
-    """Handles streaming updates to a Streamlit interface."""
-
-    def __init__(self, st: Any, initial_text: str = "") -> None:
-        """Initialize the StreamHandler with Streamlit context and initial text."""
-        self.st = st
-        self.tool_expander = st.expander("Tool Calls:", expanded=False)
-        self.container = st.empty()
-        self.text = initial_text
-        self.tools_logs = initial_text
-
-    def new_token(self, token: str) -> None:
-        """Add a new token to the main text display."""
-        self.text += token
-        self.container.markdown(format_content(self.text), unsafe_allow_html=True)
-
-    def new_status(self, status_update: str) -> None:
-        """Add a new status update to the tool calls expander."""
-        self.tools_logs += status_update
-        self.tool_expander.markdown(status_update)
-
-
-class EventProcessor:
-    """Processes events from the stream and updates the UI accordingly."""
-
-    def __init__(self, st: Any, client: Client, stream_handler: StreamHandler) -> None:
-        """Initialize the EventProcessor with Streamlit context, client, and stream handler."""
-        self.st = st
-        self.client = client
-        self.stream_handler = stream_handler
-        self.final_content = ""
-        self.tool_calls: list[dict[str, Any]] = []
-        self.additional_kwargs: dict[str, Any] = {}
-
-    def process_events(self) -> None:
-        """Process events from the stream, handling each event type appropriately."""
-        messages = self.st.session_state.user_chats[
-            self.st.session_state["session_id"]
-        ]["messages"]
-
-        session = self.st.session_state["session_id"]
-        stream = self.client.stream_messages(
-            data={
-                "message": messages[-1]["content"],
-                "events": messages[:-1],
-                "user_id": self.st.session_state["user_id"],
-                "session_id": self.st.session_state["session_id"],
-            }
-        )
-
-        for message in stream:
-            event = Event.model_validate(message)
-
-            # Skip processing if event has no content or parts
-            if not event.content or not event.content.parts:
-                continue
-
-            # Process each part in the event content
-            for part in event.content.parts:
-                # Case 1: Process function/tool calls
-                if part.function_call:
-                    # Extract tool call information
-                    tool_call = {
-                        "name": part.function_call.name,
-                        "args": part.function_call.args,
-                        "id": part.function_call.id,
-                    }
-
-                    # Track tool calls and update UI
-                    self.tool_calls.append(event.model_dump())
-                    tool_message = (
-                        f"\n\nCalling tool: `{tool_call['name']}` "
-                        f"with args: `{tool_call['args']}`"
-                    )
-                    self.stream_handler.new_status(tool_message)
-
-                    # Add to conversation history
-                    self.st.session_state.user_chats[session]["messages"].append(
-                        event.model_dump(mode="json")
-                    )
-                # Case 2: Process function/tool responses
-                elif part.function_response:
-                    # Extract response content
-                    content = str(part.function_response.response)
-
-                    # Track responses and update UI
-                    self.tool_calls.append(event.model_dump())
-                    response_message = f"\n\nTool response: `{content}`"
-                    self.stream_handler.new_status(response_message)
-
-                    # Add to conversation history
-                    self.st.session_state.user_chats[session]["messages"].append(
-                        event.model_dump(mode="json")
-                    )
-                # Case 3: Process text responses
-                elif part.text:
-                    if event.is_final_response():
-                        # Store the final response in conversation history
-                        self.st.session_state.user_chats[session]["messages"].append(
-                            event.model_dump(mode="json")
-                        )
-                        # Save the invocation ID - it might be used by the feedback functionality
-                        self.st.session_state["invocation_id"] = event.invocation_id
-                    else:
-                        # For streaming chunks, accumulate text and update UI
-                        self.final_content += part.text
-                        self.stream_handler.new_token(part.text)
-
-
-def get_chain_response(st: Any, client: Client, stream_handler: StreamHandler) -> None:
-    """Process the chain response update the Streamlit UI.
-
-    This function initiates the event processing for a chain of operations,
-    involving an AI model's response generation and potential tool calls.
-    It creates an EventProcessor instance and starts the event processing loop.
-
-    Args:
-        st (Any): The Streamlit app instance, used for accessing session state
-                 and updating the UI.
-        client (Client): An instance of the Client class used to stream events
-                        from the server.
-        stream_handler (StreamHandler): An instance of the StreamHandler class
-                                      used to update the Streamlit UI with
-                                      streaming content.
-
-    Returns:
-        None
-
-    Side effects:
-        - Updates the Streamlit UI with streaming tokens and tool call information.
-        - Modifies the session state to include the final AI message and run ID.
-        - Handles various events like chain starts/ends, tool calls, and model outputs.
-    """
-    processor = EventProcessor(st, client, stream_handler)
-    processor.process_events()

src/frontends/streamlit_adk/frontend/utils/title_summary.py

@@ -1,129 +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="assignment"
-import os
-from typing import Any
-
-import google.auth
-from google import genai
-from google.adk.events.event import Event
-from google.genai.types import Content, GenerateContentConfig, HttpOptions, Part
-
-SYS_INSTRUCTION = """Given a list of messages between a human and AI, come up with a short and relevant title for the conversation. Use up to 10 words. The title needs to be concise.
-Examples:
-**Input:**
-```
-Human: hi, what is the best italian dish?
-AI: That's a tough one! Italy has so many amazing dishes, it's hard to pick just one "best." To help me give you a great suggestion, tell me a little more about what you're looking for.
-```
-**Output:** Best italian dish
-
-**Input:**
-
-```
-Human: How to fix a broken laptop screen?
-AI: Fixing a broken laptop screen can be tricky and often requires professional help. However, there are a few things you can try at home before resorting to a repair shop.
-```
-
-**Output:** Fixing a broken laptop screen
-
-**Input:**
-
-```
-Human: Can you write me a poem about the beach?
-AI: As the sun dips down below the horizon
-And the waves gently kiss the shore,
-I sit here and watch the ocean
-And feel its power evermore.
-```
-
-**Output:** Poem about the beach
-
-**Input:**
-
-```
-Human: What's the best way to learn to code?
-AI: There are many ways to learn to code, and the best method for you will depend on your learning style and goals.
-```
-
-**Output:** How to learn to code
-
-If there's not enough context in the conversation to create a meaningful title, create a generic title like "New Conversation", or "A simple greeting".
-
-"""
-
-
-class TitleGenerator:
-    """Generates concise titles for conversations using Gemini model."""
-
-    def __init__(self) -> None:
-        _, project_id = google.auth.default()
-
-        self.client = genai.Client(
-            http_options=HttpOptions(api_version="v1"),
-            vertexai=True,
-            project=project_id,
-            location=os.getenv("LOCATION", "us-central1"),
-        )
-
-    def summarize(self, events: list[Event]) -> str:
-        """Generates a title based on a list of conversation events."""
-        contents = []
-        # Extract text content from each event and add it to the contents list
-        for event in events:
-            if event.get("content") and event["content"].get("parts"):
-                text_parts = [
-                    part.get("text", "")
-                    for part in event["content"]["parts"]
-                    if part.get("text")
-                ]
-                text_content = "\n".join(text_parts)
-                if text_content.strip():
-                    contents.append(
-                        Content(
-                            role=event["content"].get("role", "user"),
-                            parts=[Part.from_text(text=text_content)],
-                        )
-                    )
-        contents.append(
-            Content(
-                role="user",
-                parts=[
-                    Part.from_text(text="End of conversation - Create one single title")
-                ],
-            )
-        )
-        response = self.client.models.generate_content(
-            model="gemini-2.0-flash-001",
-            contents=contents,
-            config=GenerateContentConfig(
-                system_instruction=SYS_INSTRUCTION,
-                max_output_tokens=10,
-                temperature=0,
-            ),
-        ).text
-        return response
-
-
-class DummySummarizer:
-    """A simple summarizer that returns a fixed string."""
-
-    def __init__(self) -> None:
-        """Initialize the dummy summarizer."""
-        pass
-
-    def summarize(self, **kwargs: Any) -> str:
-        """Return a simple summary string regardless of input."""
-        return "Conversation"

src/resources/containers/data_processing/Dockerfile

@@ -1,27 +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.
-
-FROM python:3.11-slim
-
-RUN pip install --no-cache-dir \
-    "bigframes==1.36.0" \
-    "langchain==0.3.18" \
-    "markdownify==0.14.1" \
-    "swifter==1.4.0" \
-    "google-cloud-aiplatform>=1.80.0" \
-    "kfp>=1.4.0" \
-    "google-cloud-discoveryengine==0.13.6" \
-    "backoff==2.2.1" \
-    "google-cloud-pipeline-components==2.19.0" \
-    "langchain-google-vertexai==2.0.13"

src/resources/containers/e2e-tests/Dockerfile

@@ -1,19 +0,0 @@
-FROM ghcr.io/astral-sh/uv:python3.11-bookworm-slim
-RUN apt-get update && apt-get install -y wget sudo apt-transport-https ca-certificates gnupg curl software-properties-common && \
-    # Setup GitHub CLI
-    sudo mkdir -p -m 755 /etc/apt/keyrings && \
-    wget -q -O- https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null && \
-    sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg && \
-    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && \
-    # Setup Google Cloud SDK
-    echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list && \
-    curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key --keyring /usr/share/keyrings/cloud.google.gpg add - && \
-    # Setup Terraform
-    wget -q -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg > /dev/null && \
-    echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list > /dev/null && \
-    # Install all packages at once
-    apt-get update && \
-    apt-get install -y gh google-cloud-cli terraform && \
-    # Clean up
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*

src/resources/idx/.idx/dev.nix

@@ -1,57 +0,0 @@
-
-# To learn more about how to use Nix to configure your environment
-# see: https://firebase.google.com/docs/studio/customize-workspace
-{ pkgs, ... }: {
-  # Which nixpkgs channel to use.
-  channel = "stable-24.11"; # or "unstable"
-
-  # Use https://search.nixos.org/packages to find packages
-  packages = [
-    pkgs.python311
-    pkgs.python311Packages.pip
-    pkgs.python311Packages.uv
-    pkgs.gnumake
-    pkgs.terraform
-    pkgs.gh
-  ];
-  # Sets environment variables in the workspace
-  env = {};
-  idx = {
-    # Search for the extensions you want on https://open-vsx.org/ and use "publisher.id"
-    extensions = [
-      "ms-toolsai.jupyter"
-      "ms-python.python"
-      "krish-r.vscode-toggle-terminal"
-    ];
-    workspace = {
-      # Runs when a workspace is first created with this `dev.nix` file
-      onCreate = {
-        create-venv = ''
-        # Load environment variables from .env file if it exists
-        source .env
-        echo "Logging into gcloud..."
-        echo "Please authenticate with Google Cloud by following the prompts."
-        gcloud auth login --update-adc --brief --quiet
-
-        echo "Setting gcloud project..."
-        gcloud config set project $GOOGLE_CLOUD_PROJECT
-
-        echo "Creating Python virtual environment and installing packages..."
-        uv venv && uv pip install agent-starter-pack
-        echo "alias agent-starter-pack=\"~/$WS_NAME/.venv/bin/agent-starter-pack\"" >> ~/.bashrc
-        source ~/.bashrc
-
-        echo "Running agent starter pack creation..."
-        uv run agent-starter-pack create $AGENT_NAME
-        code ~/$WS_NAME/$AGENT_NAME/README.md
-        exec bash
-        '';
-        # Open editors for the following files by default, if they exist:
-        default.openFiles = [];
-      };
-      # To run something each time the workspace is (re)started, use the `onStart` hook
-    };
-    # Enable previews and customize configuration
-    previews = {};
-  };
-}

src/resources/idx/idx-template.json

@@ -1,21 +0,0 @@
-{
-  "name": "Agent Starter Pack",
-  "description": "Production-ready Gen AI Agent templates for Google Cloud. Addressing common challenges (Deployment & Operations, Evaluation, Customization, Observability) in building and deploying GenAI agents.",
-  "icon": "https://github.com/GoogleCloudPlatform/agent-starter-pack/blob/main/docs/images/icon.png?raw=true",
-  "params": [
-    {
-      "id": "agent_name",
-      "name": "Agent Name",
-      "description": "The name of the agent being created.",
-      "type": "string",
-      "required": true
-    },
-    {
-      "id": "google_cloud_project_id",
-      "name": "Your Goole Cloud Project ID",
-      "description": "The Google Cloud Platform Project ID where resources will be managed.",
-      "type": "string",
-      "required": true
-    }
-  ]
-}

src/resources/idx/idx-template.nix

@@ -1,26 +0,0 @@
-# No user-configurable parameters
-# Accept additional arguments to this template corresponding to template
-# parameter IDs
-{ pkgs, agent_name ? "", google_cloud_project_id ? "", ... }: {
-  # Shell script that produces the final environment
-  bootstrap = ''
-    # Copy the folder containing the `idx-template` files to the final
-    # project folder for the new workspace. ${./.} inserts the directory
-    # of the checked-out Git folder containing this template.
-    cp -rf ${./.} "$out"
-
-    # Set some permissions
-    chmod -R +w "$out"
-
-    # Create .env file with the parameter values
-    cat > "$out/.env" << EOF
-    AGENT_NAME=${agent_name}
-    GOOGLE_CLOUD_PROJECT=${google_cloud_project_id}
-    WS_NAME=$WS_NAME
-    EOF
-
-    # Remove the template files themselves and any connection to the template's
-    # Git repository
-    rm -rf "$out/.git" "$out/idx-template".{nix,json}
-  '';
-}