agent-starter-pack 0.15.7__py3-none-any.whl → 0.17.0__py3-none-any.whl

agents/crewai_coding_crew/app/agent.py

@@ -1,86 +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="union-attr"
-from langchain_core.messages import BaseMessage
-from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import tool
-from langchain_google_vertexai import ChatVertexAI
-from langgraph.graph import END, MessagesState, StateGraph
-from langgraph.prebuilt import ToolNode
-
-from .crew.crew import DevCrew
-
-LOCATION = "global"
-LLM = "gemini-2.5-flash"
-
-
-@tool
-def coding_tool(code_instructions: str) -> str:
-    """Use this tool to write a python program given a set of requirements and or instructions."""
-    inputs = {"code_instructions": code_instructions}
-    return DevCrew().crew().kickoff(inputs=inputs)
-
-
-tools = [coding_tool]
-
-# 2. Set up the language model
-llm = ChatVertexAI(
-    model=LLM, location=LOCATION, temperature=0, max_tokens=4096, streaming=True
-).bind_tools(tools)
-
-
-# 3. Define workflow components
-def should_continue(state: MessagesState) -> str:
-    """Determines whether to use the crew or end the conversation."""
-    last_message = state["messages"][-1]
-    return "dev_crew" if last_message.tool_calls else END
-
-
-def call_model(state: MessagesState, config: RunnableConfig) -> dict[str, BaseMessage]:
-    """Calls the language model and returns the response."""
-    system_message = (
-        "You are an expert Lead Software Engineer Manager.\n"
-        "Your role is to speak to a user and understand what kind of code they need to "
-        "build.\n"
-        "Part of your task is therefore to gather requirements and clarifying ambiguity "
-        "by asking followup questions. Don't ask all the questions together as the user "
-        "has a low attention span, rather ask a question at the time.\n"
-        "Once the problem to solve is clear, you will call your tool for writing the "
-        "solution.\n"
-        "Remember, you are an expert in understanding requirements but you cannot code, "
-        "use your coding tool to generate a solution. Keep the test cases if any, they "
-        "are useful for the user."
-    )
-
-    messages_with_system = [{"type": "system", "content": system_message}] + state[
-        "messages"
-    ]
-    # Forward the RunnableConfig object to ensure the agent is capable of streaming the response.
-    response = llm.invoke(messages_with_system, config)
-    return {"messages": response}
-
-
-# 4. Create the workflow graph
-workflow = StateGraph(MessagesState)
-workflow.add_node("agent", call_model)
-workflow.add_node("dev_crew", ToolNode(tools))
-workflow.set_entry_point("agent")
-
-# 5. Define graph edges
-workflow.add_conditional_edges("agent", should_continue)
-workflow.add_edge("dev_crew", "agent")
-
-# 6. Compile the workflow
-agent = workflow.compile()

agents/langgraph_base_react/app/agent.py

@@ -1,73 +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="union-attr"
-from langchain_core.messages import BaseMessage
-from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import tool
-from langchain_google_vertexai import ChatVertexAI
-from langgraph.graph import END, MessagesState, StateGraph
-from langgraph.prebuilt import ToolNode
-
-LOCATION = "global"
-LLM = "gemini-2.5-flash"
-
-
-# 1. Define tools
-@tool
-def search(query: str) -> str:
-    """Simulates a web search. Use it get information on weather"""
-    if "sf" in query.lower() or "san francisco" in query.lower():
-        return "It's 60 degrees and foggy."
-    return "It's 90 degrees and sunny."
-
-
-tools = [search]
-
-# 2. Set up the language model
-llm = ChatVertexAI(
-    model=LLM, location=LOCATION, temperature=0, max_tokens=1024, streaming=True
-).bind_tools(tools)
-
-
-# 3. Define workflow components
-def should_continue(state: MessagesState) -> str:
-    """Determines whether to use tools or end the conversation."""
-    last_message = state["messages"][-1]
-    return "tools" if last_message.tool_calls else END
-
-
-def call_model(state: MessagesState, config: RunnableConfig) -> dict[str, BaseMessage]:
-    """Calls the language model and returns the response."""
-    system_message = "You are a helpful AI assistant."
-    messages_with_system = [{"type": "system", "content": system_message}] + state[
-        "messages"
-    ]
-    # Forward the RunnableConfig object to ensure the agent is capable of streaming the response.
-    response = llm.invoke(messages_with_system, config)
-    return {"messages": response}
-
-
-# 4. Create the workflow graph
-workflow = StateGraph(MessagesState)
-workflow.add_node("agent", call_model)
-workflow.add_node("tools", ToolNode(tools))
-workflow.set_entry_point("agent")
-
-# 5. Define graph edges
-workflow.add_conditional_edges("agent", should_continue)
-workflow.add_edge("tools", "agent")
-
-# 6. Compile the workflow
-agent = workflow.compile()

agents/live_api/README.md

@@ -1,37 +0,0 @@
-# Multimodal Live Agent
-
-This pattern showcases a real-time conversational agent powered by Google Gemini. The agent handles audio, video, and text interactions while leveraging tool calling capabilities for enhanced responses.
-
-![live_api_diagram](https://storage.googleapis.com/github-repo/generative-ai/sample-apps/e2e-gen-ai-app-starter-pack/live_api_diagram.png)
-
-**Key components:**
-
-- **Python Backend** (in `app/` folder): A production-ready server built with [FastAPI](https://fastapi.tiangolo.com/) and [google-genai](https://googleapis.github.io/python-genai/) that features:
-
-  - **Real-time bidirectional communication** via WebSockets between the frontend and Gemini model
-  - **Integrated tool calling** with a weather information tool for demonstrating external data retrieval
-  - **Production-grade reliability** with retry logic and automatic reconnection capabilities
-  - **Deployment flexibility** supporting both AI Studio and Vertex AI endpoints
-  - **Feedback logging endpoint** for collecting user interactions
-
-- **React Frontend** (in `frontend/` folder): Extends the [Multimodal live API Web Console](https://github.com/google-gemini/multimodal-live-api-web-console), with added features like **custom URLs** and **feedback collection**.
-
-![live api demo](https://storage.googleapis.com/github-repo/generative-ai/sample-apps/e2e-gen-ai-app-starter-pack/live_api_pattern_demo.gif)
-
-Once both the backend and frontend are running, click the play button in the frontend UI to establish a connection with the backend. You can now interact with the Multimodal Live Agent! You can try asking questions such as "What's the weather like in San Francisco?" to see the agent use its weather information tool.
-
-## Additional Resources for Multimodal Live API
-
-Explore these resources to learn more about the Multimodal Live API and see examples of its usage:
-
-- [Project Pastra](https://github.com/heiko-hotz/gemini-multimodal-live-dev-guide/tree/main): a comprehensive developer guide for the Gemini Multimodal Live API.
-- [Google Cloud Multimodal Live API demos and samples](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/gemini/multimodal-live-api): Collection of code samples and demo applications leveraging multimodal live API in Vertex AI
-- [Gemini 2 Cookbook](https://github.com/google-gemini/cookbook/tree/main/gemini-2): Practical examples and tutorials for working with Gemini 2
-- [Multimodal Live API Web Console](https://github.com/google-gemini/multimodal-live-api-web-console): Interactive React-based web interface for testing and experimenting with Gemini Multimodal Live API.
-
-## Current Status & Future Work
-
-This pattern is under active development. Key areas planned for future enhancement include:
-
-*   **Observability:** Implementing comprehensive monitoring and tracing features.
-*   **Load Testing:** Integrating load testing capabilities.

agents/live_api/app/agent.py

@@ -1,72 +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
-
-import google.auth
-import vertexai
-from google import genai
-from google.genai import types
-
-# Constants
-VERTEXAI = os.getenv("VERTEXAI", "true").lower() == "true"
-LOCATION = "us-central1"
-MODEL_ID = "gemini-live-2.5-flash-preview-native-audio"
-
-# Initialize Google Cloud clients
-credentials, project_id = google.auth.default()
-vertexai.init(project=project_id, location=LOCATION)
-
-
-if VERTEXAI:
-    genai_client = genai.Client(project=project_id, location=LOCATION, vertexai=True)
-else:
-    # API key should be set using GOOGLE_API_KEY environment variable
-    genai_client = genai.Client(http_options={"api_version": "v1alpha"})
-
-
-def get_weather(query: str) -> dict:
-    """Simulates a web search. Use it get information on weather.
-
-    Args:
-        query: A string containing the location to get weather information for.
-
-    Returns:
-        A string with the simulated weather information for the queried location.
-    """
-    if "sf" in query.lower() or "san francisco" in query.lower():
-        return {"output": "It's 60 degrees and foggy."}
-    return {"output": "It's 90 degrees and sunny."}
-
-
-# Configure tools available to the agent and live connection
-tool_functions = {"get_weather": get_weather}
-
-live_connect_config = types.LiveConnectConfig(
-    response_modalities=[types.Modality.AUDIO],
-    tools=list(tool_functions.values()),
-    system_instruction=types.Content(
-        parts=[
-            types.Part(
-                text="""You are a helpful AI assistant designed to provide accurate and useful information. You are able to accommodate different languages and tones of voice."""
-            )
-        ]
-    ),
-    speech_config=types.SpeechConfig(
-        voice_config=types.VoiceConfig(
-            prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Kore")
-        )
-    ),
-    enable_affective_dialog=True,
-)

agents/live_api/tests/integration/test_server_e2e.py

@@ -1,260 +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 asyncio
-import json
-import logging
-import os
-import subprocess
-import sys
-import threading
-import time
-import uuid
-from collections.abc import Iterator
-from typing import Any
-
-import pytest
-import requests
-import websockets.client
-
-# Configure logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-BASE_URL = "ws://127.0.0.1:8000/"
-WS_URL = BASE_URL + "ws"
-
-FEEDBACK_URL = "http://127.0.0.1:8000/feedback"
-HEADERS = {"Content-Type": "application/json"}
-
-
-def log_output(pipe: Any, log_func: Any) -> None:
-    """Log the output from the given pipe."""
-    for line in iter(pipe.readline, ""):
-        log_func(line.strip())
-
-
-def start_server() -> subprocess.Popen[str]:
-    """Start the FastAPI server using subprocess and log its output."""
-    command = [
-        sys.executable,
-        "-m",
-        "uvicorn",
-        "app.server:app",
-        "--host",
-        "0.0.0.0",
-        "--port",
-        "8000",
-    ]
-    env = os.environ.copy()
-    env["INTEGRATION_TEST"] = "TRUE"
-    process = subprocess.Popen(
-        command,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        bufsize=1,
-        env=env,
-        encoding="utf-8",
-    )
-
-    # Start threads to log stdout and stderr in real-time
-    threading.Thread(
-        target=log_output, args=(process.stdout, logger.info), daemon=True
-    ).start()
-    threading.Thread(
-        target=log_output, args=(process.stderr, logger.error), daemon=True
-    ).start()
-
-    return process
-
-
-def wait_for_server(timeout: int = 60, interval: int = 1) -> bool:
-    """Wait for the server to be ready."""
-    start_time = time.time()
-    while time.time() - start_time < timeout:
-        try:
-            response = requests.get("http://127.0.0.1:8000/docs", timeout=10)
-            if response.status_code == 200:
-                logger.info("Server is ready")
-                return True
-        except Exception:
-            pass
-        time.sleep(interval)
-    logger.error(f"Server did not become ready within {timeout} seconds")
-    return False
-
-
-@pytest.fixture(scope="session")
-def server_fixture(request: Any) -> Iterator[subprocess.Popen[str]]:
-    """Pytest fixture to start and stop the server for testing."""
-    logger.info("Starting server process")
-    server_process = start_server()
-    if not wait_for_server():
-        pytest.fail("Server failed to start")
-    logger.info("Server process started")
-
-    def stop_server() -> None:
-        logger.info("Stopping server process")
-        server_process.terminate()
-        try:
-            server_process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            logger.warning("Server process did not terminate, killing it")
-            server_process.kill()
-            server_process.wait()
-        logger.info("Server process stopped")
-
-    request.addfinalizer(stop_server)
-    yield server_process
-
-
-@pytest.mark.asyncio
-async def test_websocket_connection(server_fixture: subprocess.Popen[str]) -> None:
-    """Test the websocket connection and message exchange."""
-
-    async def send_message(websocket: Any, message: dict[str, Any]) -> None:
-        """Helper function to send messages and log them."""
-        await websocket.send(json.dumps(message))
-
-    async def receive_message(websocket: Any, timeout: float = 5.0) -> dict[str, Any]:
-        """Helper function to receive messages with timeout."""
-        try:
-            response = await asyncio.wait_for(websocket.recv(), timeout=timeout)
-            if isinstance(response, bytes):
-                return json.loads(response.decode())
-            if isinstance(response, str):
-                return json.loads(response)
-            return response
-        except asyncio.TimeoutError as exc:
-            raise TimeoutError(
-                f"No response received within {timeout} seconds"
-            ) from exc
-
-    try:
-        await asyncio.sleep(2)
-
-        async with websockets.connect(
-            WS_URL, ping_timeout=10, close_timeout=10
-        ) as websocket:
-            try:
-                # Wait for initial ready message
-                initial_response = None
-                for _ in range(10):
-                    try:
-                        initial_response = await receive_message(websocket, timeout=5.0)
-                        if (
-                            initial_response is not None
-                            and initial_response.get("status")
-                            == "Backend is ready for conversation"
-                        ):
-                            break
-                    except TimeoutError:
-                        if _ == 9:
-                            raise
-                        continue
-
-                assert (
-                    initial_response is not None
-                    and initial_response.get("status")
-                    == "Backend is ready for conversation"
-                )
-
-                # Send messages
-                setup_msg = {"setup": {"run_id": "test-run", "user_id": "test-user"}}
-                await send_message(websocket, setup_msg)
-
-                dummy_audio = bytes([0] * 1024)
-                audio_msg = {
-                    "realtimeInput": {
-                        "mediaChunks": [
-                            {
-                                "mimeType": "audio/pcm;rate=16000",
-                                "data": dummy_audio.hex(),
-                            }
-                        ]
-                    }
-                }
-                await send_message(websocket, audio_msg)
-
-                text_msg = {
-                    "clientContent": {
-                        "turns": [
-                            {"role": "user", "parts": [{"text": "Hello, how are you?"}]}
-                        ],
-                        "turnComplete": True,
-                    }
-                }
-                await send_message(websocket, text_msg)
-
-                # Collect responses with timeout
-                responses = []
-                try:
-                    while True:
-                        try:
-                            response = await receive_message(websocket, timeout=10.0)
-                            responses.append(response)
-                            if (
-                                len(responses) >= 3
-                            ):  # Exit after receiving enough responses
-                                break
-                        except TimeoutError:
-                            break
-                except asyncio.TimeoutError:
-                    logger.info("Response collection timed out")
-
-                # Verify responses
-                assert len(responses) > 0, "No responses received from server"
-                assert any(
-                    isinstance(r, dict) and "serverContent" in r for r in responses
-                )
-                logger.info(
-                    f"Test completed successfully. Received {len(responses)} responses"
-                )
-
-            finally:
-                # Ensure websocket is closed properly
-                await websocket.close()
-
-    except Exception as e:
-        logger.error(f"Test failed with error: {e!s}")
-        raise
-
-    finally:
-        # Clean up any remaining tasks
-        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-        for task in tasks:
-            task.cancel()
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
-
-
-def test_collect_feedback(server_fixture: subprocess.Popen[str]) -> None:
-    """
-    Test the feedback collection endpoint (/feedback) to ensure it properly
-    logs the received feedback.
-    """
-    # Create sample feedback data
-    feedback_data = {
-        "score": 4,
-        "text": "Great response!",
-        "run_id": str(uuid.uuid4()),
-        "user_id": "user1",
-        "log_type": "feedback",
-    }
-
-    response = requests.post(
-        FEEDBACK_URL, json=feedback_data, headers=HEADERS, timeout=10
-    )
-    assert response.status_code == 200

agents/live_api/tests/load_test/load_test.py

@@ -1,40 +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 time
-
-from locust import HttpUser, between, task
-
-
-class DummyUser(HttpUser):
-    """Simulates a user for testing purposes."""
-
-    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
-
-    @task
-    def dummy_task(self) -> None:
-        """A dummy task that simulates work without making actual requests."""
-        # Simulate some processing time
-        time.sleep(0.1)
-
-        # Record a successful dummy request
-        self.environment.events.request.fire(
-            request_type="POST",
-            name="dummy_endpoint",
-            response_time=100,
-            response_length=1024,
-            response=None,
-            context={},
-            exception=None,
-        )