aip-agents-binary 0.0.0__py3-none-any.whl

aip_agents/credentials/manager.py

@@ -0,0 +1,132 @@
+"""Manages credentials for different model providers."""
+
+from __future__ import annotations
+
+import os
+
+from aip_agents.schema.model_id import ModelId, ModelProvider
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class CredentialsManager:
+    """Manages credentials for different model providers."""
+
+    _ENV_VAR_MAP: dict[ModelProvider, str] = {
+        ModelProvider.OPENAI: "OPENAI_API_KEY",
+        ModelProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
+        ModelProvider.AZURE_OPENAI: "AZURE_OPENAI_API_KEY",
+        ModelProvider.OPENAI_COMPATIBLE: "OPENAI_COMPATIBLE_API_KEY",
+    }
+
+    _ENV_VAR_MAP_OPENAI_COMPATIBLE: dict[str, str] = {
+        "deepseek": "DEEPSEEK_API_KEY",
+        "groq": "GROQ_DEEPSEEK_API_KEY",
+        "deepinfra": "DEEPINFRA_API_KEY",
+        "together": "TOGETHER_API_KEY",
+    }
+
+    @classmethod
+    def get_credentials(cls, model: str | ModelId, explicit_credentials: str | None = None) -> str | None:
+        """Get credentials for a given model.
+
+        Args:
+            model: The model identifier (string or ModelId object).
+            explicit_credentials: Optional explicit credentials to use instead of environment lookup.
+
+        Returns:
+            The credentials string if found, None otherwise.
+        """
+        if explicit_credentials:
+            logger.debug("Using explicitly provided credentials.")
+            return explicit_credentials
+
+        provider, path = cls._extract_provider(model)
+        if provider is None:
+            return None
+
+        return cls._get_env_credentials(provider, path or "")
+
+    @staticmethod
+    def _extract_provider(model: str | ModelId) -> tuple[ModelProvider | None, str | None]:
+        """Parse a model string or ModelId and return the provider metadata.
+
+        Args:
+            model: Raw model identifier or parsed ModelId.
+
+        Returns:
+            Tuple of provider and remaining model path when available, otherwise (None, None).
+        """
+        try:
+            if isinstance(model, str):
+                model_id_obj = ModelId.from_string(model)
+                provider = model_id_obj.provider
+                path = model_id_obj.path
+            elif isinstance(model, ModelId):
+                provider = model.provider
+                path = model.path
+            else:
+                logger.warning("Unexpected model type: %s", type(model))
+                return None, None
+
+            return provider, path
+        except ValueError:
+            logger.warning("Could not parse provider from model string: %s", model)
+            return None, None
+
+    @classmethod
+    def _extract_env_var_name(cls, provider: ModelProvider, path: str | None) -> str | None:
+        """Resolve the environment variable name to use for the given provider.
+
+        Args:
+            provider: Provider enum extracted from the model id.
+            path: Optional model path used to disambiguate OpenAI compatible providers.
+
+        Returns:
+            The name of the environment variable to load or None when no mapping exists.
+        """
+        if provider not in cls._ENV_VAR_MAP:
+            logger.info(
+                "Provider '%s' identified, but no known environment variable mapping in CredentialsManager.",
+                getattr(provider, "value", provider),
+            )
+            return None
+
+        if provider == ModelProvider.OPENAI_COMPATIBLE and path:
+            for key, env_var in cls._ENV_VAR_MAP_OPENAI_COMPATIBLE.items():
+                if key in path:
+                    return env_var
+
+        return cls._ENV_VAR_MAP[provider]
+
+    @classmethod
+    def _get_env_credentials(cls, provider: ModelProvider, path: str | None) -> str | None:
+        """Fetch credentials for the provider from the environment.
+
+        Args:
+            provider: Provider used to determine the environment variable.
+            path: Optional additional path information for provider-specific overrides.
+
+        Returns:
+            The credential string from the environment or None if it was not set.
+        """
+        env_var_name = cls._extract_env_var_name(provider, path)
+        if not env_var_name:
+            return None
+
+        env_credentials = os.environ.get(env_var_name)
+        if env_credentials:
+            logger.info(
+                "Using credentials for %s from environment variable '%s'.",
+                getattr(provider, "value", provider),
+                env_var_name,
+            )
+            return env_credentials
+
+        logger.warning(
+            "Environment variable '%s' not found for %s.",
+            env_var_name,
+            getattr(provider, "value", provider),
+        )
+        return None

aip_agents/examples/__init__.py

@@ -0,0 +1,5 @@
+"""Examples package for aip-agents.
+
+This package contains example implementations demonstrating various use cases
+and patterns for building agents with the aip-agents framework.
+"""

aip_agents/examples/audio_livekit_session.py

@@ -0,0 +1,116 @@
+"""[DEMO] LiveKit voice session backed by an AIP agent.
+
+Run (from python/aip-agents):
+  poetry run python -m aip_agents.examples.audio_livekit_session
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from contextlib import suppress
+
+from dotenv import find_dotenv, load_dotenv
+from langgraph.checkpoint.memory import MemorySaver
+
+from aip_agents.agent import LangGraphReactAgent
+from aip_agents.audio_interface import (
+    AudioIOConfig,
+    AudioModelConfig,
+    AudioSessionConfig,
+    LiveKitConfig,
+    create_audio_session,
+)
+from aip_agents.schema.step_limit import StepLimitConfig
+from aip_agents.tools.web_search.serper_tool import GoogleSerperTool
+
+
+def main() -> None:
+    """Run the LiveKit audio demo session."""
+    dotenv_path = find_dotenv(usecwd=True)
+    if dotenv_path:
+        load_dotenv(dotenv_path)
+
+    try:
+        max_steps = int(os.environ.get("AIP_AUDIO_MAX_STEPS", "8"))
+    except ValueError:
+        max_steps = 8
+
+    agent = LangGraphReactAgent(
+        name="AIP",
+        instruction=(
+            "You are AIP, the GDPLabs-native AI Agent.\n"
+            "\n"
+            "You are running in a LiveKit voice session: user speech is transcribed to text and provided to you.\n"
+            "Treat incoming messages as the user's voice (do not claim you 'can't hear audio').\n"
+            "\n"
+            "You have access to a web search tool (`google_serper`) for up-to-date info when needed.\n"
+            "\n"
+            "For responsiveness in voice mode, do at most 2 tool calls per user turn. "
+            "If results are insufficient, ask one focused follow-up question.\n"
+            "\n"
+            "When asked about your identity, say you are AIP."
+        ),
+        model="openai/gpt-5-mini",
+        tools=[GoogleSerperTool()],
+        step_limit_config=StepLimitConfig(max_steps=max_steps),
+        checkpointer=MemorySaver(),
+    )
+
+    livekit_url = os.environ.get("LIVEKIT_URL")
+    livekit_api_key = os.environ.get("LIVEKIT_API_KEY")
+    livekit_api_secret = os.environ.get("LIVEKIT_API_SECRET")
+    livekit_room_name = os.environ.get("LIVEKIT_ROOM_NAME")
+    livekit_identity = os.environ.get("LIVEKIT_IDENTITY") or "aip-agent"
+
+    missing = [
+        name
+        for name, value in (
+            ("LIVEKIT_URL", livekit_url),
+            ("LIVEKIT_API_KEY", livekit_api_key),
+            ("LIVEKIT_API_SECRET", livekit_api_secret),
+            ("LIVEKIT_ROOM_NAME", livekit_room_name),
+            ("SERPER_API_KEY", os.environ.get("SERPER_API_KEY")),
+        )
+        if not value
+    ]
+    if missing:
+        raise SystemExit(
+            "Missing required env vars for LiveKit demo: "
+            f"{', '.join(missing)}.\n\n"
+            "Fix: set them in `python/aip-agents/.env` (recommended) or export them."
+        )
+
+    audio_cfg = AudioSessionConfig(
+        provider="livekit",
+        io=AudioIOConfig(input_enabled=True, output_enabled=True),
+        model=AudioModelConfig(provider="openai", voice=os.environ.get("OPENAI_TTS_VOICE") or "echo"),
+        provider_config=LiveKitConfig(
+            url=str(livekit_url),
+            api_key=str(livekit_api_key),
+            api_secret=str(livekit_api_secret),
+            room_name=str(livekit_room_name),
+            identity=str(livekit_identity),
+        ),
+    )
+
+    session = create_audio_session(audio_cfg)
+
+    async def _run() -> None:
+        await session.start(agent, instructions=agent.instruction)
+        try:
+            await session.wait_closed()
+        finally:
+            # Ensure we shut down LiveKit/HTTP contexts before the loop closes.
+            with suppress(Exception):
+                await asyncio.shield(session.stop())
+
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        # asyncio.run() will cancel the main task; cleanup happens in _run()'s finally.
+        return
+
+
+if __name__ == "__main__":
+    main()