amd-gaia 0.15.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

gaia/agents/summarize/prompts.py

@@ -0,0 +1,129 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+"""
+Prompts and styles for the SummarizerAgent.
+"""
+
+# Summary styles
+SUMMARY_STYLES = {
+    "brief": """Write a VERY concise summary.
+STRICT RULES:
+- Limit to at most 3 sentences.
+- Do not use bullet points.
+- Avoid lists of any kind.
+- Highlight only the 2–3 most essential takeaways.
+- Exclude filler phrases (e.g., "Overall", "In summary", "This document discusses…").""",
+    "detailed": """Write a COMPREHENSIVE, richly detailed summary with metric-focused extraction.
+STRICT RULES:
+- At least 10 sentences or 250+ words.
+- Extract and include ALL quantitative data: numbers, percentages, dollar amounts, dates, metrics, KPIs
+- For business documents, structure as: Current Performance → Financial Projections → Market Analysis → Strategy
+- Identify and name: competitors, partners, target customers, specific technologies
+- Include complete financial breakdowns when present (fund allocation, revenue projections, cost structure)
+- Capture traction indicators: customer count, revenue, growth rates, retention metrics, market validation
+- Cover complete context, motivations, decisions, reasoning, and implications.
+- Retain all key technical details, timelines, and constraints.
+- Structure the content into clear, coherent paragraphs.
+- Do not use bullet points.""",
+    "bullets": """Write the ENTIRE summary as bullet points.
+STRICT RULES:
+- Use no more than 3 bullets for the whole summary.
+- Start every line with "- ".
+- Do not include paragraphs.
+- Keep each sentence under 20 words.
+- Express exactly one clear idea per bullet.
+- Emphasize actionable insights, decisions, and major facts.""",
+    "executive": """Write a high-level EXECUTIVE SUMMARY with strict prioritization.
+STRICT RULES:
+- Limit to a maximum of 5 sentences.
+- PRIORITIZE in this exact order:
+  1. Quantitative metrics (revenue, customers, growth rates, retention)
+  2. Financial data (funding amounts, projections, valuations, ROI)
+  3. Strategic outcomes and business impact
+  4. Key differentiators and competitive advantages
+- ALWAYS include specific numbers when present: revenue, customers, percentages, dollar amounts, timelines
+- For business proposals/investor documents: MUST include current traction, funding ask/allocation, and projections
+- Exclude qualitative marketing descriptions unless no metrics exist
+- Maintain a formal, board-ready, outcome-focused tone.
+- Do not use bullet points.""",
+    "participants": """Extract ONLY meeting participants.
+STRICT RULES:
+- Produce a bullet list as the only output.
+- Format every line exactly as: "- Name — Role".
+- If the role is unclear, infer only when safe; otherwise use "Role not specified".
+- Do not add any narrative or summary.
+- Do not mention actions or outcomes.""",
+    "action_items": """Extract ONLY action items.
+STRICT RULES:
+- Output only a bullet list.
+- Use this exact format for each bullet:
+  "- Action: <description>; Owner: <person or team>; Deadline: <date or 'Not specified'>"
+- Do not include any additional text.
+- Include items that are explicitly stated or clearly implied.
+- Avoid any inference beyond what is safely justified.""",
+}
+
+# System prompts for different input types
+SYSTEM_PROMPTS = {
+    "transcript": """You are a professional meeting summarizer. Analyze meeting transcripts to extract key information,
+decisions, and action items. Be precise and comprehensive.""",
+    "email": """You are a professional email summarizer. Analyze emails to extract key information, requests, and
+required actions. Focus on the sender's intent and recipient's needed response.""",
+    "pdf": """You are a professional document summarizer specializing in extracting critical quantitative data.
+
+DOCUMENT TYPE AWARENESS:
+- For business proposals/investor decks: Prioritize traction metrics (customers, revenue, ARR, growth rates, retention), 
+  financial projections, fund allocation, market sizing, competitive landscape, and exit strategy
+- For financial reports: Focus on revenue, expenses, margins, projections, and key performance indicators
+- For technical specs: Emphasize capabilities, performance metrics, implementation details, and requirements
+
+EXTRACTION PRIORITIES:
+1. All numbers: revenue, customers, percentages, dollar amounts, growth rates, metrics
+2. Named entities: competitors, partners, customers, products, technologies
+3. Financial data: projections, allocations, valuations, ROI, costs
+4. Strategic information: market size, competitive advantages, timelines
+5. Qualitative descriptions: only after all quantitative data is captured
+
+Never sacrifice metrics for marketing language. Investors need proof, not promises.""",
+}
+
+# Templates for different operations
+ITERATIVE_SUMMARY_TEMPLATE = """You are updating a cumulative summary of a long document.
+
+CRITICAL INSTRUCTIONS:
+- Read the existing summary and the new chunk carefully.
+- Identify NEW facts, details, or information in the new chunk that are NOT already present in the existing summary.
+- Do NOT repeat, restate, rephrase, or copy ANY information already in the existing summary.
+- Output ONLY the new sentences to be appended (no preamble, no reformulation of existing content).
+- Do NOT include transition phrases like "Additionally" or "Furthermore" - just the raw new facts.
+
+MAINTAIN THE STYLE:
+{style_instruction}
+
+Existing summary (DO NOT MODIFY OR REPEAT):
+{previous_summary}
+
+New Chunk:
+{new_chunk}
+
+Output ONLY the new sentences to append to the summary:
+"""
+
+DOCUMENT_SUMMARY_TEMPLATE = """{style_instruction}
+
+Please summarize the following document text:
+
+{document_text}"""
+
+DETECTION_PROMPT_TEMPLATE = """You are a strict classifier. Read the text and classify it as either an email or a meeting transcript.
+
+Definitions:
+- transcript: multiple speakers/dialogue, timestamps or speaker labels, conversational flow.
+- email: From/To/Subject headers or email-like structure, greeting/closing, single author perspective.
+
+Output requirement:
+Respond with EXACTLY one lowercase word and nothing else: transcript OR email.
+
+Text:
+{text_excerpt}"""

gaia/api/__init__.py

@@ -1,23 +1,23 @@
-# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
-# SPDX-License-Identifier: MIT
-"""
-GAIA OpenAI-Compatible API
-
-This module provides an OpenAI-compatible REST API for GAIA agents.
-Agents can be accessed via standard OpenAI client libraries.
-
-Usage:
-    # Start server
-    gaia api start --port 8080
-
-    # Use with OpenAI client
-    from openai import OpenAI
-    client = OpenAI(base_url="http://localhost:8080/v1", api_key="dummy")
-
-    response = client.chat.completions.create(
-        model="gaia-code-agent",
-        messages=[{"role": "user", "content": "Write hello world"}]
-    )
-"""
-
-__version__ = "1.0.0"
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""
+GAIA OpenAI-Compatible API
+
+This module provides an OpenAI-compatible REST API for GAIA agents.
+Agents can be accessed via standard OpenAI client libraries.
+
+Usage:
+    # Start server
+    gaia api start --port 8080
+
+    # Use with OpenAI client
+    from openai import OpenAI
+    client = OpenAI(base_url="http://localhost:8080/v1", api_key="dummy")
+
+    response = client.chat.completions.create(
+        model="gaia-code-agent",
+        messages=[{"role": "user", "content": "Write hello world"}]
+    )
+"""
+
+__version__ = "1.0.0"

gaia/api/agent_registry.py

@@ -1,238 +1,238 @@
-# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
-# SPDX-License-Identifier: MIT
-"""
-Agent Registry - Exposes GAIA agents as OpenAI "models"
-
-GAIA doesn't manage LLM models (Lemonade does that). Instead, we expose
-GAIA agents as "models" in the OpenAI API, allowing users to select which
-agent type they want to use.
-
-Example:
-    User selects "gaia-code" model -> Routes to CodeAgent
-    User selects "gaia-jira" model -> Routes to JiraAgent
-
-This is a simple hardcoded mapping for users to select agent types.
-"""
-
-import logging
-import os
-import time
-from typing import Any, Dict, List
-
-from gaia.agents.base.agent import Agent
-from gaia.agents.base.api_agent import ApiAgent
-from gaia.api.sse_handler import SSEOutputHandler
-
-logger = logging.getLogger(__name__)
-
-
-# Hardcoded agent mappings: "model" name -> (Agent class, init params)
-# These are the "models" exposed in /v1/models and selectable in VSCode
-AGENT_MODELS = {
-    "gaia-code": {
-        "class_name": "gaia.agents.routing.agent.RoutingAgent",
-        "init_params": {
-            "api_mode": True,  # Skip interactive questions, use defaults/best-guess
-            "silent_mode": True,
-            "streaming": False,
-            "max_steps": 100,
-        },
-        "description": "Intelligent routing agent that detects language/project type and routes to CodeAgent",
-    }
-}
-
-
-# Apply environment variable overrides to all agent init_params
-# These are set by app.py when starting the API server with debug flags
-def _apply_env_overrides():
-    """
-    Read environment variables set by `gaia api start` and override agent init_params.
-
-    Environment variables:
-        GAIA_API_DEBUG: Enable debug logging and console output
-        GAIA_API_SHOW_PROMPTS: Display prompts sent to LLM
-        GAIA_API_STREAMING: Enable real-time streaming of LLM responses
-        GAIA_API_STEP_THROUGH: Enable step-through debugging mode
-    """
-    debug = os.environ.get("GAIA_API_DEBUG") == "1"
-    show_prompts = os.environ.get("GAIA_API_SHOW_PROMPTS") == "1"
-    streaming = os.environ.get("GAIA_API_STREAMING") == "1"
-
-    # Apply overrides to all agents
-    for model_id, config in AGENT_MODELS.items():
-        init_params = config["init_params"]
-
-        # When debug is enabled, disable silent_mode to show console output
-        if debug:
-            init_params["debug"] = True
-            init_params["silent_mode"] = False
-            logger.info(f"Debug mode enabled for {model_id}")
-
-        if show_prompts:
-            init_params["show_prompts"] = True
-            logger.info(f"Show prompts enabled for {model_id}")
-
-        if streaming:
-            init_params["streaming"] = True
-            logger.info(f"Streaming enabled for {model_id}")
-
-
-# Apply environment overrides at module import time
-_apply_env_overrides()
-
-
-class AgentRegistry:
-    """
-    Registry that exposes GAIA agents as OpenAI-compatible "models".
-
-    Note: These aren't LLM models - they're GAIA agent types.
-    Lemonade handles the actual LLM models underneath.
-    """
-
-    def __init__(self):
-        """Initialize registry with hardcoded agents"""
-        self._loaded_classes: Dict[str, type] = {}
-
-    def _load_agent_class(self, class_path: str) -> type:
-        """
-        Dynamically load agent class from module path.
-
-        Args:
-            class_path: Full module path (e.g., "gaia.agents.code.agent.CodeAgent")
-
-        Returns:
-            Agent class
-        """
-        if class_path in self._loaded_classes:
-            return self._loaded_classes[class_path]
-
-        module_path, class_name = class_path.rsplit(".", 1)
-        module = __import__(module_path, fromlist=[class_name])
-        cls = getattr(module, class_name)
-
-        self._loaded_classes[class_path] = cls
-        return cls
-
-    def get_agent(self, model_id: str) -> Agent:
-        """
-        Instantiate and return agent for model ID with SSE output handler.
-
-        Args:
-            model_id: Model ID (e.g., "gaia-code", "gaia-jira")
-
-        Returns:
-            Agent instance configured for API streaming
-
-        Raises:
-            ValueError: If model_id not found
-
-        Example:
-            >>> registry = AgentRegistry()
-            >>> agent = registry.get_agent("gaia-code")
-            >>> result = agent.process_query("Write hello world")
-        """
-        if model_id not in AGENT_MODELS:
-            available = ", ".join(AGENT_MODELS.keys())
-            raise ValueError(
-                f"Model '{model_id}' not found. " f"Available models: {available}"
-            )
-
-        config = AGENT_MODELS[model_id]
-
-        try:
-            agent_class = self._load_agent_class(config["class_name"])
-            init_params = config["init_params"].copy()
-
-            # Check if debug mode is enabled
-            debug_mode = os.environ.get("GAIA_API_DEBUG") == "1"
-
-            # API layer always uses SSEOutputHandler for streaming to clients
-            # Pass debug_mode flag to control verbosity
-            init_params["output_handler"] = SSEOutputHandler(debug_mode=debug_mode)
-
-            if debug_mode:
-                logger.debug(f"Creating agent {model_id} with debug mode enabled")
-
-            return agent_class(**init_params)
-        except ImportError as e:
-            logger.error(f"Failed to load agent {model_id}: {e}")
-            raise ValueError(f"Agent {model_id} not available: {e}")
-
-    def list_models(self) -> List[Dict[str, Any]]:
-        """
-        Return OpenAI-compatible model list.
-
-        Note: These are GAIA agents exposed as "models", not LLM models.
-
-        Returns:
-            List of model metadata dicts for /v1/models endpoint
-
-        Example:
-            >>> registry = AgentRegistry()
-            >>> models = registry.list_models()
-            >>> [m["id"] for m in models]
-            ['gaia-code', 'gaia-jira']
-        """
-        models = []
-
-        for model_id, config in AGENT_MODELS.items():
-            try:
-                # Try to load agent to get metadata (if it implements ApiAgent)
-                agent_class = self._load_agent_class(config["class_name"])
-                agent = agent_class(**config["init_params"])
-
-                # Get model info (custom if ApiAgent, default otherwise)
-                if isinstance(agent, ApiAgent):
-                    model_info = agent.get_model_info()
-                    logger.debug(
-                        f"Agent {model_id} provides custom model info: {model_info}"
-                    )
-                else:
-                    model_info = {
-                        "max_input_tokens": 8192,
-                        "max_output_tokens": 4096,
-                    }
-                    logger.debug(f"Agent {model_id} using default model info")
-            except Exception as e:
-                # Agent not available or initialization failed, use defaults
-                logger.warning(f"Agent {model_id} not available ({e}), using defaults")
-                model_info = {
-                    "max_input_tokens": 8192,
-                    "max_output_tokens": 4096,
-                }
-
-            models.append(
-                {
-                    "id": model_id,
-                    "object": "model",
-                    "created": int(time.time()),
-                    "owned_by": "amd-gaia",
-                    "description": config.get("description", ""),
-                    **model_info,
-                }
-            )
-
-        return models
-
-    def model_exists(self, model_id: str) -> bool:
-        """
-        Check if model ID exists.
-
-        Args:
-            model_id: Model ID to check
-
-        Returns:
-            True if model exists, False otherwise
-
-        Example:
-            >>> registry = AgentRegistry()
-            >>> registry.model_exists("gaia-code")
-            True
-            >>> registry.model_exists("nonexistent")
-            False
-        """
-        return model_id in AGENT_MODELS
-
-
-# Global registry instance
-registry = AgentRegistry()
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""
+Agent Registry - Exposes GAIA agents as OpenAI "models"
+
+GAIA doesn't manage LLM models (Lemonade does that). Instead, we expose
+GAIA agents as "models" in the OpenAI API, allowing users to select which
+agent type they want to use.
+
+Example:
+    User selects "gaia-code" model -> Routes to CodeAgent
+    User selects "gaia-jira" model -> Routes to JiraAgent
+
+This is a simple hardcoded mapping for users to select agent types.
+"""
+
+import logging
+import os
+import time
+from typing import Any, Dict, List
+
+from gaia.agents.base.agent import Agent
+from gaia.agents.base.api_agent import ApiAgent
+from gaia.api.sse_handler import SSEOutputHandler
+
+logger = logging.getLogger(__name__)
+
+
+# Hardcoded agent mappings: "model" name -> (Agent class, init params)
+# These are the "models" exposed in /v1/models and selectable in VSCode
+AGENT_MODELS = {
+    "gaia-code": {
+        "class_name": "gaia.agents.routing.agent.RoutingAgent",
+        "init_params": {
+            "api_mode": True,  # Skip interactive questions, use defaults/best-guess
+            "silent_mode": True,
+            "streaming": False,
+            "max_steps": 100,
+        },
+        "description": "Intelligent routing agent that detects language/project type and routes to CodeAgent",
+    }
+}
+
+
+# Apply environment variable overrides to all agent init_params
+# These are set by app.py when starting the API server with debug flags
+def _apply_env_overrides():
+    """
+    Read environment variables set by `gaia api start` and override agent init_params.
+
+    Environment variables:
+        GAIA_API_DEBUG: Enable debug logging and console output
+        GAIA_API_SHOW_PROMPTS: Display prompts sent to LLM
+        GAIA_API_STREAMING: Enable real-time streaming of LLM responses
+        GAIA_API_STEP_THROUGH: Enable step-through debugging mode
+    """
+    debug = os.environ.get("GAIA_API_DEBUG") == "1"
+    show_prompts = os.environ.get("GAIA_API_SHOW_PROMPTS") == "1"
+    streaming = os.environ.get("GAIA_API_STREAMING") == "1"
+
+    # Apply overrides to all agents
+    for model_id, config in AGENT_MODELS.items():
+        init_params = config["init_params"]
+
+        # When debug is enabled, disable silent_mode to show console output
+        if debug:
+            init_params["debug"] = True
+            init_params["silent_mode"] = False
+            logger.info(f"Debug mode enabled for {model_id}")
+
+        if show_prompts:
+            init_params["show_prompts"] = True
+            logger.info(f"Show prompts enabled for {model_id}")
+
+        if streaming:
+            init_params["streaming"] = True
+            logger.info(f"Streaming enabled for {model_id}")
+
+
+# Apply environment overrides at module import time
+_apply_env_overrides()
+
+
+class AgentRegistry:
+    """
+    Registry that exposes GAIA agents as OpenAI-compatible "models".
+
+    Note: These aren't LLM models - they're GAIA agent types.
+    Lemonade handles the actual LLM models underneath.
+    """
+
+    def __init__(self):
+        """Initialize registry with hardcoded agents"""
+        self._loaded_classes: Dict[str, type] = {}
+
+    def _load_agent_class(self, class_path: str) -> type:
+        """
+        Dynamically load agent class from module path.
+
+        Args:
+            class_path: Full module path (e.g., "gaia.agents.code.agent.CodeAgent")
+
+        Returns:
+            Agent class
+        """
+        if class_path in self._loaded_classes:
+            return self._loaded_classes[class_path]
+
+        module_path, class_name = class_path.rsplit(".", 1)
+        module = __import__(module_path, fromlist=[class_name])
+        cls = getattr(module, class_name)
+
+        self._loaded_classes[class_path] = cls
+        return cls
+
+    def get_agent(self, model_id: str) -> Agent:
+        """
+        Instantiate and return agent for model ID with SSE output handler.
+
+        Args:
+            model_id: Model ID (e.g., "gaia-code", "gaia-jira")
+
+        Returns:
+            Agent instance configured for API streaming
+
+        Raises:
+            ValueError: If model_id not found
+
+        Example:
+            >>> registry = AgentRegistry()
+            >>> agent = registry.get_agent("gaia-code")
+            >>> result = agent.process_query("Write hello world")
+        """
+        if model_id not in AGENT_MODELS:
+            available = ", ".join(AGENT_MODELS.keys())
+            raise ValueError(
+                f"Model '{model_id}' not found. " f"Available models: {available}"
+            )
+
+        config = AGENT_MODELS[model_id]
+
+        try:
+            agent_class = self._load_agent_class(config["class_name"])
+            init_params = config["init_params"].copy()
+
+            # Check if debug mode is enabled
+            debug_mode = os.environ.get("GAIA_API_DEBUG") == "1"
+
+            # API layer always uses SSEOutputHandler for streaming to clients
+            # Pass debug_mode flag to control verbosity
+            init_params["output_handler"] = SSEOutputHandler(debug_mode=debug_mode)
+
+            if debug_mode:
+                logger.debug(f"Creating agent {model_id} with debug mode enabled")
+
+            return agent_class(**init_params)
+        except ImportError as e:
+            logger.error(f"Failed to load agent {model_id}: {e}")
+            raise ValueError(f"Agent {model_id} not available: {e}")
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        """
+        Return OpenAI-compatible model list.
+
+        Note: These are GAIA agents exposed as "models", not LLM models.
+
+        Returns:
+            List of model metadata dicts for /v1/models endpoint
+
+        Example:
+            >>> registry = AgentRegistry()
+            >>> models = registry.list_models()
+            >>> [m["id"] for m in models]
+            ['gaia-code', 'gaia-jira']
+        """
+        models = []
+
+        for model_id, config in AGENT_MODELS.items():
+            try:
+                # Try to load agent to get metadata (if it implements ApiAgent)
+                agent_class = self._load_agent_class(config["class_name"])
+                agent = agent_class(**config["init_params"])
+
+                # Get model info (custom if ApiAgent, default otherwise)
+                if isinstance(agent, ApiAgent):
+                    model_info = agent.get_model_info()
+                    logger.debug(
+                        f"Agent {model_id} provides custom model info: {model_info}"
+                    )
+                else:
+                    model_info = {
+                        "max_input_tokens": 8192,
+                        "max_output_tokens": 4096,
+                    }
+                    logger.debug(f"Agent {model_id} using default model info")
+            except Exception as e:
+                # Agent not available or initialization failed, use defaults
+                logger.warning(f"Agent {model_id} not available ({e}), using defaults")
+                model_info = {
+                    "max_input_tokens": 8192,
+                    "max_output_tokens": 4096,
+                }
+
+            models.append(
+                {
+                    "id": model_id,
+                    "object": "model",
+                    "created": int(time.time()),
+                    "owned_by": "amd-gaia",
+                    "description": config.get("description", ""),
+                    **model_info,
+                }
+            )
+
+        return models
+
+    def model_exists(self, model_id: str) -> bool:
+        """
+        Check if model ID exists.
+
+        Args:
+            model_id: Model ID to check
+
+        Returns:
+            True if model exists, False otherwise
+
+        Example:
+            >>> registry = AgentRegistry()
+            >>> registry.model_exists("gaia-code")
+            True
+            >>> registry.model_exists("nonexistent")
+            False
+        """
+        return model_id in AGENT_MODELS
+
+
+# Global registry instance
+registry = AgentRegistry()